From 91cea9e7beef4c7bca379ca198920c6bd5529534 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 17:18:31 +0300 Subject: [PATCH 01/10] Add an embedder-chosen standard-library package set Stdlib names the packages an embedder offers: the core packages plus the optional ones it enables. Compiling, discovery, the capability catalog and host-function installation read the same set, so an optional package is either fully present or fully absent. The existing free functions keep their behavior through Stdlib::core(). No optional package exists yet. Co-Authored-By: Claude Opus 5.5 --- .../interpreter/src/capability_derivation.rs | 2 +- crates/interpreter/src/compile.rs | 59 ++- crates/interpreter/src/lib.rs | 1 + crates/interpreter/src/packages.rs | 340 +++++++++++------- crates/interpreter/src/runtime/call_log.rs | 4 +- crates/interpreter/src/runtime/host.rs | 22 +- crates/interpreter/src/runtime/mod.rs | 3 +- crates/interpreter/src/stdlib/capabilities.rs | 86 ++++- crates/interpreter/src/stdlib/mod.rs | 205 ++++++++++- crates/interpreter/src/stdlib/shared.rs | 2 +- .../src/typechecker/infer/imports.rs | 11 +- 11 files changed, 563 insertions(+), 172 deletions(-) diff --git a/crates/interpreter/src/capability_derivation.rs b/crates/interpreter/src/capability_derivation.rs index 5d3eb4913..95f2290d5 100644 --- a/crates/interpreter/src/capability_derivation.rs +++ b/crates/interpreter/src/capability_derivation.rs @@ -193,7 +193,7 @@ fn normalized_string( } fn field_normalization(capability: &str, field: &str) -> FieldNormalization { - capabilities::find(capability) + capabilities::find_any(capability) .and_then(|entry| entry.filter_fields.iter().find(|f| f.name == field)) .map_or(FieldNormalization::Verbatim, |f| f.normalization) } diff --git a/crates/interpreter/src/compile.rs b/crates/interpreter/src/compile.rs index 7282a0783..30abed2f7 100644 --- a/crates/interpreter/src/compile.rs +++ b/crates/interpreter/src/compile.rs @@ -9,6 +9,7 @@ use std::time::{Duration, Instant}; use crate::compile_capabilities; use crate::compiler_error::{CompileError, CompilerFailure, CompilerStage}; use crate::runtime::prelude; +use crate::stdlib::Stdlib; use crate::typechecker::rules::check_script; use crate::typed_ast::TypedAst; use crate::{ @@ -75,7 +76,12 @@ impl ParsedScript { } if let Some(server) = module.strip_prefix("@mcp/") { imports.mcp_servers.insert(server.to_string()); - } else if stdlib_names.contains(module) { + } else if stdlib_names.contains(module) + || crate::stdlib::OptionalPackage::from_module_name(module).is_some() + { + // An optional package counts as stdlib whether or not the embedder + // enables it: a disabled one is reported as unavailable, never + // looked up as a registry package. imports.stdlib.insert(module.clone()); } else { imports.registry_packages.insert(module.clone()); @@ -256,7 +262,29 @@ pub fn typecheck_checked(source: &str, file: FileId) -> Result, fn typecheck_script(source: &str, file: FileId) -> Result, CompileError> { let parsed = parse_script(source, file); let stdlib_defs = runtime::stdlib_package_declarations(); - let (ta, diags, _timings) = front_end(source, &parsed, &stdlib_defs, &[])?; + typecheck_parsed_script(source, &parsed, &stdlib_defs) +} + +/// [`typecheck_checked`] for an already parsed script, against `stdlib_defs` +/// (see [`Stdlib::package_declarations`](crate::stdlib::Stdlib::package_declarations)). +pub fn typecheck_parsed_checked( + source: &str, + parsed: &ParsedScript, + stdlib_defs: &[PackageDeclaration], +) -> Result, CompileError> { + let file = parsed.file; + typecheck_parsed_script(source, parsed, stdlib_defs).map_err(|error| { + error.with_limit_span_cut(|span_file| (span_file == file).then_some(source)) + }) +} + +fn typecheck_parsed_script( + source: &str, + parsed: &ParsedScript, + stdlib_defs: &[PackageDeclaration], +) -> Result, CompileError> { + let file = parsed.file; + let (ta, diags, _timings) = front_end(source, parsed, stdlib_defs, &[])?; if has_errors(&diags) { return Err(diags.into()); } @@ -499,10 +527,32 @@ pub fn compile_package_with_transitive_checked( modules: &[PackageSourceModule<'_>], dependencies: &[&PackageDeclaration], transitive: &[&PackageDeclaration], +) -> Result { + compile_package_with_transitive_in_checked( + Stdlib::core(), + package_name, + root_module, + modules, + dependencies, + transitive, + ) +} + +/// [`compile_package_with_transitive_checked`] for an embedder that offers +/// `stdlib`, so the package may import its optional packages. +pub fn compile_package_with_transitive_in_checked( + stdlib: Stdlib, + package_name: &str, + root_module: ModulePath, + modules: &[PackageSourceModule<'_>], + dependencies: &[&PackageDeclaration], + transitive: &[&PackageDeclaration], ) -> Result { let mut sources = Sources::new(); + let stdlib_defs = stdlib.package_declarations(); compile_package_sources( &mut sources, + &stdlib_defs, package_name, root_module, modules, @@ -516,6 +566,7 @@ pub fn compile_package_with_transitive_checked( fn compile_package_sources( sources: &mut Sources, + stdlib_defs: &[PackageDeclaration], package_name: &str, root_module: ModulePath, modules: &[PackageSourceModule<'_>], @@ -552,7 +603,6 @@ fn compile_package_sources( .iter() .map(|(path, file, ast)| (path.clone(), *file, ast)) .collect(); - let stdlib_defs = runtime::stdlib_package_declarations(); let mut external_packages: BTreeMap = stdlib_defs .iter() .map(|defs| (defs.package_name.clone(), defs.clone())) @@ -593,7 +643,7 @@ fn compile_package_sources( compile_capabilities::derive_package_requirements( &declaration, &ta, - &stdlib_defs, + stdlib_defs, dependencies, transitive, ) @@ -633,7 +683,6 @@ fn compile_package_sources( fatal: Some(fatal), })?; - let stdlib_defs = runtime::stdlib_package_declarations(); let mut codegen_deps: Vec<&PackageDeclaration> = prelude_defs.iter().collect(); codegen_deps.extend(host_defs.iter()); codegen_deps.extend(internal_defs.iter()); diff --git a/crates/interpreter/src/lib.rs b/crates/interpreter/src/lib.rs index 07bf2c6a4..4e4eeb33f 100644 --- a/crates/interpreter/src/lib.rs +++ b/crates/interpreter/src/lib.rs @@ -81,6 +81,7 @@ pub use runtime::{RunResult, RuntimeConfig, dispatch_main_async, instantiate_pro pub use shape::Shape; pub use source::{ModulePath, SourceFile, Sources}; pub use span::{FileId, LineIndex, Span}; +pub use stdlib::{OptionalPackage, Stdlib}; pub use token::{Token, TokenKind}; pub use type_info::{FieldInfo, TypeInfo, TypeInfoId, TypeInfoIndex, TypeInfoKind, TypeInfoTable}; pub use typechecker::{capability_binding_type, capture, check, desugar, infer, infer_package}; diff --git a/crates/interpreter/src/packages.rs b/crates/interpreter/src/packages.rs index 081f36eeb..bb1466ced 100644 --- a/crates/interpreter/src/packages.rs +++ b/crates/interpreter/src/packages.rs @@ -12,7 +12,7 @@ use std::collections::{BTreeMap, BTreeSet}; use std::fmt::Write; use crate::runtime::prelude::declaration::prelude_package_declaration; -use crate::stdlib::stdlib_package_declarations; +use crate::stdlib::Stdlib; use crate::types::escape_string_literal; use crate::{ ClassExtends, DocCapabilityBindingKind, DocCapabilityLiteral, DocComment, FileId, @@ -41,28 +41,40 @@ pub struct ModuleSummary { /// handle `@mcp/*` and unknown names). Every module resolves, opt-in ones such /// as `submilli:git` included; what a caller's scope shows is its own decision. pub fn docs(name: &str) -> Option { - user_modules() - .into_iter() - .find(|d| d.package_name == name) - .map(|defs| ModuleDoc { - name: defs.package_name.clone(), - description: module_description(&defs.package_name).to_string(), - declarations: render_declarations(&defs), - }) + Stdlib::core().docs(name) } /// Modules whose name, description, or an exported symbol contains `query` /// (case-insensitive). An empty query lists every module. pub fn search(query: &str) -> Vec { - let q = query.trim().to_lowercase(); - user_modules() - .iter() - .filter(|defs| matches_query(defs, &q)) - .map(|defs| ModuleSummary { - name: defs.package_name.clone(), - description: module_description(&defs.package_name).to_string(), - }) - .collect() + Stdlib::core().search(query) +} + +impl Stdlib { + /// [`docs`] over the modules of this set. + pub fn docs(self, name: &str) -> Option { + user_modules(self) + .into_iter() + .find(|d| d.package_name == name) + .map(|defs| ModuleDoc { + name: defs.package_name.clone(), + description: module_description(&defs.package_name).to_string(), + declarations: render_declarations(&defs), + }) + } + + /// [`search`] over the modules of this set. + pub fn search(self, query: &str) -> Vec { + let q = query.trim().to_lowercase(); + user_modules(self) + .iter() + .filter(|defs| matches_query(defs, &q)) + .map(|defs| ModuleSummary { + name: defs.package_name.clone(), + description: module_description(&defs.package_name).to_string(), + }) + .collect() + } } /// The language built-ins always in scope without an `import`: headline prelude @@ -548,24 +560,31 @@ pub enum Resolution { /// Try `name` as a stdlib module, then as a built-in. Every discovery surface /// runs this same ladder so MCP, REST, and the CLI reach the same answer. pub fn resolve(name: &str) -> Resolution { - if let Some(doc) = docs(name) { - return Resolution::Module(doc); - } - match builtin_lookup(name) { - BuiltinLookup::Found(declarations) => Resolution::Builtin { - name: name.to_string(), - declarations, - }, - BuiltinLookup::UnknownMember { - path, - member, - members, - } => Resolution::UnknownMember { - path, - member, - members, - }, - BuiltinLookup::Unknown => Resolution::Unknown, + Stdlib::core().resolve(name) +} + +impl Stdlib { + /// [`resolve`] over the modules of this set. + pub fn resolve(self, name: &str) -> Resolution { + if let Some(doc) = self.docs(name) { + return Resolution::Module(doc); + } + match builtin_lookup(name) { + BuiltinLookup::Found(declarations) => Resolution::Builtin { + name: name.to_string(), + declarations, + }, + BuiltinLookup::UnknownMember { + path, + member, + members, + } => Resolution::UnknownMember { + path, + member, + members, + }, + BuiltinLookup::Unknown => Resolution::Unknown, + } } } @@ -592,54 +611,66 @@ pub fn suggest_filtered( extra: &[String], visible: impl Fn(&str) -> bool, ) -> Option { - let mut candidates: Vec = search("").into_iter().map(|m| m.name).collect(); - let builtins = builtins(); - candidates.extend(builtins.types); - candidates.extend(builtins.namespaces); - candidates.extend(extra.iter().cloned()); - candidates.retain(|candidate| visible(candidate)); - - // Only the head segment is in question: `Temporel.Instant` misses because - // of `Temporel`, and the tail only inflates the distance past threshold. - let query = name.split('.').find(|s| !s.is_empty()).unwrap_or(name); - // `closest_match` floors its threshold at 2 edits, so a one- or two-character - // query sits within reach of an unrelated name. Below that length there is no - // signal to match on. - if query.len() < 3 { - return None; - } + Stdlib::core().suggest_filtered(name, extra, visible) +} - if let Some((_, replacement)) = OMITTED_GLOBALS - .iter() - .find(|(omitted, _)| omitted.eq_ignore_ascii_case(name)) - { - return Some((*replacement).to_string()); - } +impl Stdlib { + /// [`suggest_filtered`] over the modules of this set. + pub fn suggest_filtered( + self, + name: &str, + extra: &[String], + visible: impl Fn(&str) -> bool, + ) -> Option { + let mut candidates: Vec = self.search("").into_iter().map(|m| m.name).collect(); + let builtins = builtins(); + candidates.extend(builtins.types); + candidates.extend(builtins.namespaces); + candidates.extend(extra.iter().cloned()); + candidates.retain(|candidate| visible(candidate)); + + // Only the head segment is in question: `Temporel.Instant` misses because + // of `Temporel`, and the tail only inflates the distance past threshold. + let query = name.split('.').find(|s| !s.is_empty()).unwrap_or(name); + // `closest_match` floors its threshold at 2 edits, so a one- or two-character + // query sits within reach of an unrelated name. Below that length there is no + // signal to match on. + if query.len() < 3 { + return None; + } + + if let Some((_, replacement)) = OMITTED_GLOBALS + .iter() + .find(|(omitted, _)| omitted.eq_ignore_ascii_case(name)) + { + return Some((*replacement).to_string()); + } - // Never offer the query back to the caller: a name that resolved nowhere is - // not its own repair, however it was spelled. - let is_self = |c: &String| c.eq_ignore_ascii_case(name); - if let Some(hit) = candidates - .iter() - .find(|c| !is_self(c) && name_tail(c).eq_ignore_ascii_case(query)) - { - return Some(hit.clone()); - } - // Match full names and scheme-stripped tails in one pass, so the globally - // closest key wins: `htp` should reach `submilli:http` (one edit from its - // tail) rather than whichever unrelated full name lands inside threshold. - let mut keys: Vec<(&str, &str)> = Vec::new(); - for c in candidates.iter().filter(|c| !is_self(c)) { - keys.push((c.as_str(), c.as_str())); - let tail = name_tail(c); - if tail != c.as_str() { - keys.push((tail, c.as_str())); + // Never offer the query back to the caller: a name that resolved nowhere is + // not its own repair, however it was spelled. + let is_self = |c: &String| c.eq_ignore_ascii_case(name); + if let Some(hit) = candidates + .iter() + .find(|c| !is_self(c) && name_tail(c).eq_ignore_ascii_case(query)) + { + return Some(hit.clone()); + } + // Match full names and scheme-stripped tails in one pass, so the globally + // closest key wins: `htp` should reach `submilli:http` (one edit from its + // tail) rather than whichever unrelated full name lands inside threshold. + let mut keys: Vec<(&str, &str)> = Vec::new(); + for c in candidates.iter().filter(|c| !is_self(c)) { + keys.push((c.as_str(), c.as_str())); + let tail = name_tail(c); + if tail != c.as_str() { + keys.push((tail, c.as_str())); + } } + let hit = crate::did_you_mean::closest_match(query, keys.iter().map(|(k, _)| *k))?; + keys.iter() + .find(|(k, _)| *k == hit) + .map(|(_, owner)| (*owner).to_string()) } - let hit = crate::did_you_mean::closest_match(query, keys.iter().map(|(k, _)| *k))?; - keys.iter() - .find(|(k, _)| *k == hit) - .map(|(_, owner)| (*owner).to_string()) } /// The part of a package name after its scheme or scope: `submilli:http` and @@ -709,19 +740,31 @@ pub fn catalog(extra: Vec) -> Catalog { /// Filter before applying the catalog limit so omitted counts reflect visibility. pub fn catalog_filtered(extra: Vec, visible: impl Fn(&str) -> bool) -> Catalog { - let mut entries: Vec = search("") - .into_iter() - .map(|m| CatalogEntry { - name: m.name, - source: SOURCE_STDLIB.to_string(), - description: m.description, - }) - .collect(); - entries.extend(extra); - entries.retain(|entry| visible(&entry.name)); - let remaining = entries.len().saturating_sub(CATALOG_LIMIT); - entries.truncate(CATALOG_LIMIT); - Catalog { entries, remaining } + Stdlib::core().catalog_filtered(extra, visible) +} + +impl Stdlib { + /// [`catalog_filtered`] over the modules of this set. + pub fn catalog_filtered( + self, + extra: Vec, + visible: impl Fn(&str) -> bool, + ) -> Catalog { + let mut entries: Vec = self + .search("") + .into_iter() + .map(|m| CatalogEntry { + name: m.name, + source: SOURCE_STDLIB.to_string(), + description: m.description, + }) + .collect(); + entries.extend(extra); + entries.retain(|entry| visible(&entry.name)); + let remaining = entries.len().saturating_sub(CATALOG_LIMIT); + entries.truncate(CATALOG_LIMIT); + Catalog { entries, remaining } + } } /// Name the head, then list what it actually has, so the repair is one edit. @@ -780,8 +823,9 @@ fn resolve_ignore_case<'a>(keys: impl Iterator, name: &str) - } /// The stdlib modules an agent may import, minus internal plumbing. -fn user_modules() -> Vec { - stdlib_package_declarations() +fn user_modules(stdlib: Stdlib) -> Vec { + stdlib + .package_declarations() .into_iter() .filter(|d| d.package_name != INTERNAL_MODULE) .collect() @@ -851,11 +895,18 @@ pub fn render_declarations(defs: &PackageDeclaration) -> String { /// it — the editor should complete both; `build check` remains the gate /// against importing them elsewhere. pub fn render_stdlib_d_ts() -> String { - let mut out = String::new(); - for defs in &editor_stdlib_modules() { - render_declare_module(&mut out, defs); + Stdlib::core().render_stdlib_d_ts() +} + +impl Stdlib { + /// [`render_stdlib_d_ts`] for the modules of this set. + pub fn render_stdlib_d_ts(self) -> String { + let mut out = String::new(); + for defs in &editor_stdlib_modules(self) { + render_declare_module(&mut out, defs); + } + out.trim_end().to_string() } - out.trim_end().to_string() } /// Render editor-facing TypeScript declarations for `packages`, one @@ -871,44 +922,55 @@ pub fn render_packages_d_ts( packages: &[&PackageDeclaration], context: &[&PackageDeclaration], ) -> String { - let stdlib = editor_stdlib_modules(); - let exporters = TypeExporters::new( - stdlib - .iter() - .chain(packages.iter().copied()) - .chain(context.iter().copied()), - ); - let globals = global_classes(); - let mut out = String::new(); - for defs in packages { - let _ = writeln!(out, "declare module \"{}\" {{", defs.package_name); - let imports = block_imports(defs, &exporters); - for (local, (public, module)) in &imports.types { - if local == public { - let _ = writeln!(out, " import type {{ {local} }} from \"{module}\";"); - } else { - let _ = writeln!( - out, - " import type {{ {public} as {local} }} from \"{module}\";" - ); + Stdlib::core().render_packages_d_ts(packages, context) +} + +impl Stdlib { + /// [`render_packages_d_ts`] against the modules of this set. + pub fn render_packages_d_ts( + self, + packages: &[&PackageDeclaration], + context: &[&PackageDeclaration], + ) -> String { + let stdlib = editor_stdlib_modules(self); + let exporters = TypeExporters::new( + stdlib + .iter() + .chain(packages.iter().copied()) + .chain(context.iter().copied()), + ); + let globals = global_classes(); + let mut out = String::new(); + for defs in packages { + let _ = writeln!(out, "declare module \"{}\" {{", defs.package_name); + let imports = block_imports(defs, &exporters); + for (local, (public, module)) in &imports.types { + if local == public { + let _ = writeln!(out, " import type {{ {local} }} from \"{module}\";"); + } else { + let _ = writeln!( + out, + " import type {{ {public} as {local} }} from \"{module}\";" + ); + } } + let parent = |extends: &ClassExtends| { + if let Some(local) = imports.parents.get(extends.parent.as_str()) { + return Some(ts_named_type(local, &extends.args)); + } + // A package value of the global's name would hide it; the class + // then renders without its parent rather than extend the value. + let global = globals.get(extends.parent.as_str())?; + if declares(defs, global, true) { + return None; + } + Some(ts_named_type(global, &extends.args)) + }; + render_ts_declarations(&mut out, defs, " ", "export ", &parent); + let _ = writeln!(out, "}}\n"); } - let parent = |extends: &ClassExtends| { - if let Some(local) = imports.parents.get(extends.parent.as_str()) { - return Some(ts_named_type(local, &extends.args)); - } - // A package value of the global's name would hide it; the class - // then renders without its parent rather than extend the value. - let global = globals.get(extends.parent.as_str())?; - if declares(defs, global, true) { - return None; - } - Some(ts_named_type(global, &extends.args)) - }; - render_ts_declarations(&mut out, defs, " ", "export ", &parent); - let _ = writeln!(out, "}}\n"); + out.trim_end().to_string() } - out.trim_end().to_string() } /// The built-in classes a package's class may extend, such as `Error`, by @@ -925,8 +987,8 @@ fn global_classes() -> BTreeMap { .collect() } -fn editor_stdlib_modules() -> Vec { - let mut modules = user_modules(); +fn editor_stdlib_modules(stdlib: Stdlib) -> Vec { + let mut modules = user_modules(stdlib); modules.push(crate::stdlib::test::package_declaration()); modules.push(crate::stdlib::security::package_declaration()); modules.sort_by(|a, b| a.package_name.cmp(&b.package_name)); @@ -2748,7 +2810,7 @@ mod tests { #[test] fn stdlib_capability_tags_parse_cleanly() { - for module in user_modules() { + for module in user_modules(Stdlib::core()) { for symbol in module.values.values() { let Some(doc) = value_doc(&symbol.kind) else { continue; @@ -2768,7 +2830,7 @@ mod tests { #[test] fn every_importable_stdlib_symbol_has_docs() { - for module in user_modules() { + for module in user_modules(Stdlib::core()) { for symbol in module.values.values() { assert!( value_doc(&symbol.kind).is_some(), @@ -3349,7 +3411,7 @@ mod tests { #[test] fn stdlib_d_ts_declares_each_user_module() { let docs = render_stdlib_d_ts(); - for module in user_modules() { + for module in user_modules(Stdlib::core()) { assert!( docs.contains(&format!("declare module \"{}\" {{", module.package_name)), "missing declare module for {}", diff --git a/crates/interpreter/src/runtime/call_log.rs b/crates/interpreter/src/runtime/call_log.rs index f6b8fb461..cbc6ec721 100644 --- a/crates/interpreter/src/runtime/call_log.rs +++ b/crates/interpreter/src/runtime/call_log.rs @@ -563,7 +563,7 @@ mod tests { #[test] fn every_capability_has_a_recording_class() { - for group in crate::stdlib::capabilities::catalog() { + for group in crate::stdlib::capabilities::all_groups() { for capability in group.capabilities { let classes = [REQUEST_AND_RESPONSE, RESPONSE_ONLY, TIMING_ONLY] .iter() @@ -580,7 +580,7 @@ mod tests { #[test] fn every_gating_module_ends_the_calls_it_begins() { - for group in crate::stdlib::capabilities::catalog() { + for group in crate::stdlib::capabilities::all_groups() { // The catalog names `@mcp/` imports; their calls dispatch through the // internal MCP module. let module = match group.module { diff --git a/crates/interpreter/src/runtime/host.rs b/crates/interpreter/src/runtime/host.rs index 7681f9485..6179c2d38 100644 --- a/crates/interpreter/src/runtime/host.rs +++ b/crates/interpreter/src/runtime/host.rs @@ -16,6 +16,7 @@ pub(crate) use crate::runtime::intrinsic_types::{ }; use crate::runtime::number::{parse_float_js, parse_int_with_radix, string_to_number_js}; use crate::runtime::{StoreData, read_submilli_string}; +use crate::stdlib::Stdlib; use crate::{PackageDeclaration, Param, Span, Type, ValueKind, ValueSymbol}; pub const NUMBER_MODULE_NAME: &str = "submilli:number"; @@ -31,13 +32,30 @@ pub async fn install_async( linker: &mut Linker, store: &mut Store, ) -> wasmtime::Result<()> { - install_host_functions(linker)?; + install_async_for(linker, store, Stdlib::core()).await +} + +/// [`install_async`] for an embedder that offers `stdlib`. +pub async fn install_async_for( + linker: &mut Linker, + store: &mut Store, + stdlib: Stdlib, +) -> wasmtime::Result<()> { + install_host_functions_for(linker, stdlib)?; install_store_bound(linker, store) } pub fn install_host_functions(linker: &mut Linker) -> wasmtime::Result<()> { + install_host_functions_for(linker, Stdlib::core()) +} + +/// [`install_host_functions`] for an embedder that offers `stdlib`. +pub fn install_host_functions_for( + linker: &mut Linker, + stdlib: Stdlib, +) -> wasmtime::Result<()> { install_core_host_functions(linker)?; - crate::stdlib::install_host_functions(linker)?; + stdlib.install_host_functions(linker)?; super::mcp::install_mcp_async(linker)?; Ok(()) } diff --git a/crates/interpreter/src/runtime/mod.rs b/crates/interpreter/src/runtime/mod.rs index 3b5830d6e..420d40d4b 100644 --- a/crates/interpreter/src/runtime/mod.rs +++ b/crates/interpreter/src/runtime/mod.rs @@ -44,8 +44,9 @@ pub use embedding::{ pub use exec::{RunResult, dispatch_main_async, instantiate_program_async}; pub use host::{ INTERNAL_MODULE_NAME, NUMBER_MODULE_NAME, host_package_declarations, - install_async as install_runtime_async, + install_async as install_runtime_async, install_async_for as install_runtime_async_for, install_host_functions as install_runtime_host_functions, + install_host_functions_for as install_runtime_host_functions_for, install_store_bound as install_runtime_store_bound, internal_host_package_declarations, stdlib_package_declarations, }; diff --git a/crates/interpreter/src/stdlib/capabilities.rs b/crates/interpreter/src/stdlib/capabilities.rs index 15ff8ff92..e5def1385 100644 --- a/crates/interpreter/src/stdlib/capabilities.rs +++ b/crates/interpreter/src/stdlib/capabilities.rs @@ -9,6 +9,8 @@ //! update the matching entry here — see AGENTS.md. The `capabilities` test in //! the `submilli` CLI asserts every `example_filter` below parses. +use super::{OptionalPackage, Stdlib}; + /// One context field a capability's `filter:` expression can match on. pub struct FilterField { pub name: &'static str, @@ -356,7 +358,7 @@ const HTTP: &[Capability] = &[ /// Every other method `http.request` takes, gated as `http.` with the /// method lowercased: `http.request("TRACE", …)` checks `http.trace`. Kept -/// out of [`CATALOG`], whose consumers read a templated name as +/// out of [`CORE_CATALOG`], whose consumers read a templated name as /// `mcp.` and concretize it per declared server; see /// [`uncataloged_http_method`]. pub const HTTP_OTHER_METHOD: Capability = Capability { @@ -485,7 +487,8 @@ const SESSION: &[Capability] = &[ }, ]; -const CATALOG: &[CapabilityGroup] = &[ +/// The capabilities of the core packages, which every embedder has. +const CORE_CATALOG: &[CapabilityGroup] = &[ CapabilityGroup { module: "submilli:embedding", capabilities: EMBEDDING, @@ -520,16 +523,61 @@ const CATALOG: &[CapabilityGroup] = &[ }, ]; -/// Every stdlib capability the runtime can gate, grouped by source module. +/// The capabilities of one optional package. +fn optional_group(package: OptionalPackage) -> &'static CapabilityGroup { + match package {} +} + +/// Every capability the core packages gate, grouped by source module. An +/// optional package's capabilities are listed only by [`catalog_for`]. pub fn catalog() -> &'static [CapabilityGroup] { - CATALOG + CORE_CATALOG +} + +/// Every capability the packages of `stdlib` gate, grouped by source module, +/// in [`catalog`]'s order: by module name without its `submilli:` or `@` prefix. +pub fn catalog_for(stdlib: Stdlib) -> Vec<&'static CapabilityGroup> { + let mut groups: Vec<&'static CapabilityGroup> = CORE_CATALOG.iter().collect(); + groups.extend(stdlib.optional_packages().map(optional_group)); + groups.sort_by_key(|group| catalog_order(group.module)); + groups +} + +fn catalog_order(module: &str) -> &str { + module + .strip_prefix("submilli:") + .or_else(|| module.strip_prefix('@')) + .unwrap_or(module) +} + +/// Every group the runtime can gate, whichever packages an embedder enables. +/// Runtime checks use this: a capability reaches them only from a host +/// function, which is installed only when its package is enabled. +pub(crate) fn all_groups() -> impl Iterator { + CORE_CATALOG.iter().chain( + OptionalPackage::ALL + .iter() + .map(|package| optional_group(*package)), + ) } -/// Look up a capability by its exact name (templates included, by their +/// Look up a core capability by its exact name (templates included, by their /// literal `mcp.` spelling). pub fn find(name: &str) -> Option<&'static Capability> { - CATALOG - .iter() + find_in(Stdlib::core(), name) +} + +/// [`find`] among the capabilities of `stdlib`. +pub fn find_in(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { + catalog_for(stdlib) + .into_iter() + .flat_map(|group| group.capabilities) + .find(|cap| cap.name == name) +} + +/// [`find`] among every group the runtime can gate. +pub(crate) fn find_any(name: &str) -> Option<&'static Capability> { + all_groups() .flat_map(|group| group.capabilities) .find(|cap| cap.name == name) } @@ -545,7 +593,12 @@ pub fn uncataloged_http_method(name: &str) -> Option<&str> { /// The entry describing `name`: its catalog entry, or [`HTTP_OTHER_METHOD`] /// for a name that fills it. pub fn find_gating(name: &str) -> Option<&'static Capability> { - find(name).or_else(|| uncataloged_http_method(name).map(|_| &HTTP_OTHER_METHOD)) + find_gating_in(Stdlib::core(), name) +} + +/// [`find_gating`] among the capabilities of `stdlib`. +pub fn find_gating_in(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { + find_in(stdlib, name).or_else(|| uncataloged_http_method(name).map(|_| &HTTP_OTHER_METHOD)) } /// An RFC 9110 method token, the set `http.request` accepts, in lowercase. @@ -565,8 +618,7 @@ mod tests { /// answer for every caller, so growing the set is a deliberate act. #[test] fn only_secrets_get_is_refused_to_main() { - let refused: Vec<&str> = catalog() - .iter() + let refused: Vec<&str> = all_groups() .flat_map(|group| group.capabilities) .filter(|cap| !cap.grantable_to_main()) .map(|cap| cap.name) @@ -574,10 +626,22 @@ mod tests { assert_eq!(refused, ["secrets.get"]); } + /// The core set lists exactly the core catalog, in the same order, so every + /// surface that reads `catalog()` agrees with one that reads `catalog_for`. + #[test] + fn core_set_lists_the_core_catalog() { + let core: Vec<&str> = catalog().iter().map(|group| group.module).collect(); + let for_core: Vec<&str> = catalog_for(Stdlib::core()) + .iter() + .map(|group| group.module) + .collect(); + assert_eq!(for_core, core); + } + #[test] fn catalog_entries_are_well_formed() { let mut seen = HashSet::new(); - for group in catalog() { + for group in all_groups() { for cap in group.capabilities { assert!( cap.name.contains('.') && !cap.name.is_empty(), diff --git a/crates/interpreter/src/stdlib/mod.rs b/crates/interpreter/src/stdlib/mod.rs index 880a06320..b8f3ca2cc 100644 --- a/crates/interpreter/src/stdlib/mod.rs +++ b/crates/interpreter/src/stdlib/mod.rs @@ -36,7 +36,145 @@ use wasmtime::Linker; use crate::PackageDeclaration; use crate::runtime::StoreData; +/// A standard-library package that exists only when the embedder provides it. +/// +/// Each one is backed by a provider trait the harness implements. An embedder +/// that does not enable a package gets none of it: the package cannot be +/// imported, discovery and the capability catalog do not list it, and its host +/// functions are not installed. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +#[non_exhaustive] +pub enum OptionalPackage {} + +impl OptionalPackage { + pub const ALL: &'static [OptionalPackage] = &[]; + + pub const fn module_name(self) -> &'static str { + match self {} + } + + pub fn from_module_name(name: &str) -> Option { + Self::ALL + .iter() + .copied() + .find(|package| package.module_name() == name) + } + + fn package_declaration(self) -> PackageDeclaration { + match self {} + } + + fn install(self, _linker: &mut Linker) -> wasmtime::Result<()> { + match self {} + } + + const fn bit(self) -> u8 { + match self {} + } +} + +/// The standard library an embedder offers its programs: the core packages +/// every embedder has, plus the [`OptionalPackage`]s it enables. +/// +/// Compiling, discovery, the capability catalog and host-function installation +/// all read the same set, so a package is either fully present or fully absent. +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)] +pub struct Stdlib { + optional: u8, +} + +impl Stdlib { + /// The core packages only, what `submilli run` and the server offer. + pub const fn core() -> Self { + Stdlib { optional: 0 } + } + + #[must_use] + pub const fn with(self, package: OptionalPackage) -> Self { + Stdlib { + optional: self.optional | package.bit(), + } + } + + pub const fn enables(self, package: OptionalPackage) -> bool { + self.optional & package.bit() != 0 + } + + pub fn optional_packages(self) -> impl Iterator { + OptionalPackage::ALL + .iter() + .copied() + .filter(move |package| self.enables(*package)) + } + + /// Whether `name` is a package of this set. + pub fn contains_module(self, name: &str) -> bool { + OptionalPackage::from_module_name(name).map_or_else( + || { + core_package_declarations() + .iter() + .any(|defs| defs.package_name == name) + }, + |package| self.enables(package), + ) + } + + /// Every package of this set, sorted by name. + pub fn package_declarations(self) -> Vec { + let mut declarations = core_package_declarations(); + declarations.extend( + self.optional_packages() + .map(OptionalPackage::package_declaration), + ); + // Codegen emits imports in this order, so sorting keeps builds byte-for-byte stable. + declarations.sort_by(|a, b| a.package_name.cmp(&b.package_name)); + declarations + } + + pub fn install_host_functions(self, linker: &mut Linker) -> wasmtime::Result<()> { + install_core_host_functions(linker)?; + for package in self.optional_packages() { + package.install(linker)?; + } + Ok(()) + } +} + +/// Why `module` cannot be imported though it names a standard-library package, +/// as a message and its help lines. `None` when `module` is no such package. +/// +/// Reached only for a package missing from the declarations the compile was +/// given, so an optional package here is one the embedder did not enable. +pub(crate) fn unavailable_import(module: &str) -> Option<(String, Vec)> { + if module == test::MODULE_NAME { + return Some(( + format!("package `{module}` not found"), + vec![ + "`submilli:test` is only available to test files run via `submilli build test`; it is not importable from a program run with `submilli run`" + .to_string(), + ], + )); + } + let package = OptionalPackage::from_module_name(module)?; + Some(( + format!("package `{module}` is not available in this harness"), + vec![format!( + "`{}` exists only where the harness running the program provides it", + package.module_name() + )], + )) +} + +/// The core packages: what [`Stdlib::core`] offers. pub fn stdlib_package_declarations() -> Vec { + Stdlib::core().package_declarations() +} + +pub fn install_host_functions(linker: &mut Linker) -> wasmtime::Result<()> { + Stdlib::core().install_host_functions(linker) +} + +fn core_package_declarations() -> Vec { vec![ // Alphabetical by package name; codegen import-emission relies on this order. code::package_declaration(), @@ -54,7 +192,7 @@ pub fn stdlib_package_declarations() -> Vec { ] } -pub fn install_host_functions(linker: &mut Linker) -> wasmtime::Result<()> { +fn install_core_host_functions(linker: &mut Linker) -> wasmtime::Result<()> { code::install(linker)?; crypto::install(linker)?; embedding::install(linker)?; @@ -77,3 +215,68 @@ pub(crate) fn install_store_bound( ) -> wasmtime::Result<()> { git::class::install(linker, store) } + +#[cfg(test)] +mod tests { + use super::*; + + /// Every subset of the optional packages. + fn every_set() -> Vec { + let mut sets = vec![Stdlib::core()]; + for package in OptionalPackage::ALL { + let with: Vec = sets.iter().map(|set| set.with(*package)).collect(); + sets.extend(with); + } + sets + } + + #[test] + fn declarations_are_sorted_for_every_set() { + for set in every_set() { + let names: Vec = set + .package_declarations() + .into_iter() + .map(|defs| defs.package_name) + .collect(); + let mut sorted = names.clone(); + sorted.sort(); + assert_eq!(names, sorted, "{set:?}"); + } + } + + #[test] + fn a_set_contains_exactly_its_packages() { + for set in every_set() { + let names: Vec = set + .package_declarations() + .into_iter() + .map(|defs| defs.package_name) + .collect(); + for name in &names { + assert!(set.contains_module(name), "{set:?} misses {name}"); + } + for package in OptionalPackage::ALL { + assert_eq!( + names.iter().any(|name| name == package.module_name()), + set.enables(*package), + "{set:?} and {package:?}" + ); + } + } + } + + #[test] + fn core_is_the_global_list() { + let core: Vec = Stdlib::core() + .package_declarations() + .into_iter() + .map(|defs| defs.package_name) + .collect(); + let global: Vec = stdlib_package_declarations() + .into_iter() + .map(|defs| defs.package_name) + .collect(); + assert_eq!(core, global); + assert!(!Stdlib::core().contains_module(test::MODULE_NAME)); + } +} diff --git a/crates/interpreter/src/stdlib/shared.rs b/crates/interpreter/src/stdlib/shared.rs index 58d76b934..2b71fb9b6 100644 --- a/crates/interpreter/src/stdlib/shared.rs +++ b/crates/interpreter/src/stdlib/shared.rs @@ -203,7 +203,7 @@ pub(crate) fn authorize_capability( // existing, and the default check allows everything. if caller == crate::mangle::USER_PACKAGE && let Some(reason) = - crate::stdlib::capabilities::find(capability).and_then(|entry| entry.main_denial) + crate::stdlib::capabilities::find_any(capability).and_then(|entry| entry.main_denial) { audit_denial_at( security_check, diff --git a/crates/interpreter/src/typechecker/infer/imports.rs b/crates/interpreter/src/typechecker/infer/imports.rs index e5fb3ff65..c040523ae 100644 --- a/crates/interpreter/src/typechecker/infer/imports.rs +++ b/crates/interpreter/src/typechecker/infer/imports.rs @@ -257,15 +257,8 @@ impl<'a> Inferer<'a> { ); continue; } - if module == crate::stdlib::test::MODULE_NAME { - self.error_with_help( - module_span, - format!("package `{module}` not found"), - vec![ - "`submilli:test` is only available to test files run via `submilli build test`; it is not importable from a program run with `submilli run`" - .to_string(), - ], - ); + if let Some((message, help)) = crate::stdlib::unavailable_import(&module) { + self.error_with_help(module_span, message, help); continue; } // In the closure but not declared here: the types resolve, the From e6ad946a65438a00510003580773f82935b9425a Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 17:32:57 +0300 Subject: [PATCH 02/10] Quote derived filter literals the way the policy parser reads them Call-site derivation escaped only backslash and quote, so a literal holding `${vars.` became a variable reference and control characters did not round trip. filter_string_literal now matches the policy's canonical quoting, and a value no literal can spell contributes no filter, with a warning. Co-Authored-By: Claude Opus 5.5 --- .../interpreter/src/capability_derivation.rs | 71 ++++++++++++++++++- 1 file changed, 69 insertions(+), 2 deletions(-) diff --git a/crates/interpreter/src/capability_derivation.rs b/crates/interpreter/src/capability_derivation.rs index 95f2290d5..26a40cfd5 100644 --- a/crates/interpreter/src/capability_derivation.rs +++ b/crates/interpreter/src/capability_derivation.rs @@ -156,7 +156,19 @@ fn binding_filter( return None; } let normalized = normalized_string(tag, field, value, warn_at, warnings); - format!("\"{}\"", escape(&normalized)) + let Some(literal) = filter_string_literal(&normalized) else { + if let Some(span) = warn_at { + warnings.push(warning( + span, + format!( + "`{field}` value contains `{VAR_PLACEHOLDER}`, which a filter reads as a variable reference; no static filter for `{}`", + tag.capability + ), + )); + } + return None; + }; + literal } StaticValue::Number(spelling) => spelling, StaticValue::Boolean(value) => value.to_string(), @@ -433,8 +445,33 @@ fn url_component(url: &str, component: &str) -> Option { Some(value) } +/// What a filter reads inside a quoted string as the start of a variable reference. +const VAR_PLACEHOLDER: &str = "${vars."; + +/// `value` as a quoted filter string, in the canonical form the policy parser +/// reads back as exactly `value`. `None` when no quoted string can spell it: the +/// parser reads `${vars.` inside quotes as a variable reference. +/// +/// Must agree with the policy crate's own quoting; a test there compares the two. +#[doc(hidden)] +pub fn filter_string_literal(value: &str) -> Option { + (!value.contains(VAR_PLACEHOLDER)).then(|| format!("\"{}\"", escape(value))) +} + +/// The escapes the filter tokenizer reads inside a quoted string. fn escape(value: &str) -> String { - value.replace('\\', "\\\\").replace('"', "\\\"") + let mut out = String::with_capacity(value.len()); + for ch in value.chars() { + match ch { + '"' => out.push_str("\\\""), + '\\' => out.push_str("\\\\"), + '\n' => out.push_str("\\n"), + '\t' => out.push_str("\\t"), + '\r' => out.push_str("\\r"), + c => out.push(c), + } + } + out } fn number_literal(value: f64) -> String { @@ -537,6 +574,36 @@ mod tests { assert!(derived.warnings.is_empty(), "{:?}", derived.warnings); } + /// A filter reads `${vars.` inside quotes as a variable, so no literal can spell + /// such a value: the binding is dropped, with a warning, rather than written as + /// a variable reference the program never meant. + #[test] + fn literal_holding_a_variable_reference_contributes_no_filter() { + let (ta, tag, params, args) = first_doc_capability( + "/** @capability secrets.get { name } */\n\ + function callee(name: string): void { }\n\ + function main(): void { callee(\"${vars.who}\"); }\n", + ); + let derived = derive_call_site_capability(&tag, ¶ms, &ta, &args).unwrap(); + assert_eq!(derived.filter, None); + assert!(derived.known_bindings.is_empty()); + assert_eq!(derived.warnings.len(), 1, "{:?}", derived.warnings); + assert!(derived.warnings[0].message.contains("${vars.")); + } + + #[test] + fn string_literal_escapes_what_the_filter_tokenizer_reads() { + assert_eq!( + filter_string_literal("a\"b\\c\nd\te\rf").as_deref(), + Some("\"a\\\"b\\\\c\\nd\\te\\rf\""), + ); + assert_eq!(filter_string_literal("${vars.x}"), None); + assert_eq!( + filter_string_literal("${other}").as_deref(), + Some("\"${other}\"") + ); + } + #[test] fn non_literal_arg_retains_requirement_without_warning() { let (ta, tag, params, args) = first_doc_capability( From d59628b9515f9d11334f14042254eb4a037afc2b Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 17:32:57 +0300 Subject: [PATCH 03/10] Add submilli:agents and submilli:skills as harness packages Two optional standard-library packages a harness enables through Stdlib and implements through a provider trait: AgentProvider runs sub-agents (agents.run, typed like llm.call, and list), SkillProvider serves skills (list, load, readFile). Both traits carry owned, serializable data so a harness can implement them over the wire. Neither package exists for the submilli CLI or server: importing one there reports it as not available in this harness, and discovery and the capability catalog list them only for a set that enables them. agent.run and skill.load are policy-gated like llm.call, and list() filters each candidate through the same rule. The typechecker's llm-only typed-call hook becomes a small registry so agents.run shares it; llm's diagnostics are unchanged. Co-Authored-By: Claude Opus 5.5 --- crates/interpreter/src/packages.rs | 4 + crates/interpreter/src/runtime/agents.rs | 112 ++++ crates/interpreter/src/runtime/call_log.rs | 10 + crates/interpreter/src/runtime/host.rs | 2 + crates/interpreter/src/runtime/mod.rs | 17 + crates/interpreter/src/runtime/skills.rs | 97 ++++ crates/interpreter/src/span.rs | 6 +- .../src/stdlib/agents/declaration.rs | 159 ++++++ crates/interpreter/src/stdlib/agents/mod.rs | 306 +++++++++++ crates/interpreter/src/stdlib/capabilities.rs | 39 +- crates/interpreter/src/stdlib/mod.rs | 99 +++- .../interpreter/src/stdlib/optional_tests.rs | 511 ++++++++++++++++++ crates/interpreter/src/stdlib/shared.rs | 16 +- .../src/stdlib/skills/declaration.rs | 158 ++++++ crates/interpreter/src/stdlib/skills/mod.rs | 377 +++++++++++++ .../interpreter/src/typechecker/infer/expr.rs | 68 +-- .../src/typechecker/infer/generic.rs | 26 +- docs/part-6-reference/standard-library.md | 28 +- plans/sub-1269-host-fuel-costs.md | 26 + 19 files changed, 2008 insertions(+), 53 deletions(-) create mode 100644 crates/interpreter/src/runtime/agents.rs create mode 100644 crates/interpreter/src/runtime/skills.rs create mode 100644 crates/interpreter/src/stdlib/agents/declaration.rs create mode 100644 crates/interpreter/src/stdlib/agents/mod.rs create mode 100644 crates/interpreter/src/stdlib/optional_tests.rs create mode 100644 crates/interpreter/src/stdlib/skills/declaration.rs create mode 100644 crates/interpreter/src/stdlib/skills/mod.rs diff --git a/crates/interpreter/src/packages.rs b/crates/interpreter/src/packages.rs index bb1466ced..8e94e3f5d 100644 --- a/crates/interpreter/src/packages.rs +++ b/crates/interpreter/src/packages.rs @@ -835,6 +835,9 @@ fn user_modules(stdlib: Stdlib) -> Vec { /// `packages.search`/`docs` and (manually mirrored) MVP.md §I. fn module_description(name: &str) -> &'static str { match name { + "submilli:agents" => { + "Harness sub-agents: run(agent, input), and list() to discover them." + } "submilli:crypto" => "Hashing, HMAC, and random bytes.", "submilli:code" => { "Workspace tools: numbered reads, search, glob, tree, anchored edits and unified diffs." @@ -850,6 +853,7 @@ fn module_description(name: &str) -> &'static str { "submilli:llm" => "Gated model calls: call/batch, and models() to discover them.", "submilli:secrets" => "Policy-gated access to Blueprint-declared secrets.", "submilli:session" => "Session-scoped key-value state: get/has/set/remove/list.", + "submilli:skills" => "Harness skills: list(), load(name) and readFile(name, path).", "submilli:url" => "URL parse/build and query-string handling. Pure compute.", "submilli:uuid" => "UUID v4/v7 generation and validation.", _ => "", diff --git a/crates/interpreter/src/runtime/agents.rs b/crates/interpreter/src/runtime/agents.rs new file mode 100644 index 000000000..2ca98e4d9 --- /dev/null +++ b/crates/interpreter/src/runtime/agents.rs @@ -0,0 +1,112 @@ +//! The embedder-supplied seam for `submilli:agents`: a program hands work to a +//! sub-agent and gets its result back. +//! +//! The engine owns the guest surface, the capability check and the call log; +//! the harness owns what an agent is and how it runs. Everything that crosses +//! [`AgentProvider`] is owned, serializable data, so a harness may implement it +//! in process or forward it over the wire. +//! +//! **The provider bounds the run.** The execution timeout is checked only while +//! Wasm runs, so it does not interrupt a pending host call: a sub-agent run +//! lasts as long as the provider lets it. Time limits, token spend, recursion +//! depth and cancellation of a child when its parent goes away are the +//! provider's to enforce. Dropping the future returned by +//! [`AgentProvider::run`] is how the engine cancels a run. + +use std::future::Future; +use std::pin::Pin; + +use serde::{Deserialize, Serialize}; + +pub const AGENTS_MODULE_NAME: &str = "submilli:agents"; + +/// One sub-agent run, as the program asked for it. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentRequest { + /// The agent's name, as [`AgentProvider::agents`] lists it. + pub agent: String, + /// The task for the agent. + pub input: String, + /// A JSON Schema the result must satisfy, present when the program wrote a + /// type argument. The engine checks the result against the type itself; the + /// schema tells the agent what shape to answer in. + pub schema: Option, + /// The package whose code made the call: `main` for the program itself. + pub caller: String, +} + +/// What a finished run hands back. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentOutcome { + /// The agent's final answer. When the request carried a schema, this is the + /// JSON text of a value meant to satisfy it. + pub text: String, + /// What the run cost, as far as the provider knows. Recorded in the call + /// log; the engine charges nothing for it. + pub usage: Option, +} + +/// Tokens a run spent. `None` means unknown, never zero. +#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentUsage { + pub input_tokens: Option, + pub output_tokens: Option, +} + +/// One agent a program may hand work to. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct AgentInfo { + pub name: String, + /// Operator-authored text on what the agent is for. The engine reduces it to + /// one bounded line before a program sees it. + pub description: Option, +} + +/// Why a run did not produce a result. Every message is safe to show the +/// program: none carries the input or the agent's output. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum AgentCallError { + /// No [`AgentProvider`] is wired into the runtime. + NotConfigured, + /// The harness has no agent of this name. + NotFound { agent: String }, + /// The run started and failed. `message` is a fixed classification chosen by + /// the provider, not the agent's output. + Failed { agent: String, message: String }, + /// The run was stopped before it finished. + Cancelled { agent: String }, +} + +impl std::fmt::Display for AgentCallError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::NotConfigured => write!( + f, + "no agent provider is configured: this harness does not run sub-agents" + ), + Self::NotFound { agent } => write!( + f, + "no agent named `{agent}`; call `list()` for the agents you may use" + ), + Self::Failed { agent, message } => write!(f, "agent `{agent}` failed: {message}"), + Self::Cancelled { agent } => write!(f, "agent `{agent}` was cancelled"), + } + } +} + +impl std::error::Error for AgentCallError {} + +/// The harness side of `submilli:agents`. +pub trait AgentProvider: Send + Sync { + /// Run `request.agent` on `request.input` and return its final answer. + fn run<'a>( + &'a self, + request: AgentRequest, + ) -> Pin> + Send + 'a>>; + + /// Every agent the harness offers. The engine removes the ones the policy + /// denies to the caller before the program sees the list. + fn agents<'a>( + &'a self, + ) -> Pin, AgentCallError>> + Send + 'a>>; +} diff --git a/crates/interpreter/src/runtime/call_log.rs b/crates/interpreter/src/runtime/call_log.rs index cbc6ec721..0440cab48 100644 --- a/crates/interpreter/src/runtime/call_log.rs +++ b/crates/interpreter/src/runtime/call_log.rs @@ -536,6 +536,8 @@ mod tests { "llm.call", "embedding.embed", "mcp.", + "agent.run", + "skill.load", ]; /// The request is the decision's context; the response is kept for whole reads and /// session reads. @@ -614,6 +616,14 @@ mod tests { /// host functions run it. `None` marks the shared helpers: they run inside whichever /// module calls them. const CALLING_FILES: &[(&str, Option<&str>)] = &[ + ( + "src/stdlib/agents/mod.rs", + Some(crate::stdlib::agents::MODULE_NAME), + ), + ( + "src/stdlib/skills/mod.rs", + Some(crate::stdlib::skills::MODULE_NAME), + ), ( "src/stdlib/code/mod.rs", Some(crate::stdlib::code::MODULE_NAME), diff --git a/crates/interpreter/src/runtime/host.rs b/crates/interpreter/src/runtime/host.rs index 6179c2d38..eca0537cd 100644 --- a/crates/interpreter/src/runtime/host.rs +++ b/crates/interpreter/src/runtime/host.rs @@ -1674,6 +1674,8 @@ pub(crate) const CALL_MODULES: &[&str] = &[ crate::stdlib::git::MODULE_NAME, crate::stdlib::code::MODULE_NAME, crate::stdlib::security::MODULE_NAME, + crate::stdlib::agents::MODULE_NAME, + crate::stdlib::skills::MODULE_NAME, super::mcp::MCP_MODULE_NAME, ]; diff --git a/crates/interpreter/src/runtime/mod.rs b/crates/interpreter/src/runtime/mod.rs index 420d40d4b..244879119 100644 --- a/crates/interpreter/src/runtime/mod.rs +++ b/crates/interpreter/src/runtime/mod.rs @@ -1,5 +1,6 @@ //! Wasmtime engine configuration for Submilli. +pub mod agents; pub(crate) mod array_storage; pub mod blocking; pub mod call_log; @@ -23,10 +24,15 @@ pub mod prelude; pub mod secrets; pub mod security; pub mod session_kv; +pub mod skills; pub mod token_ledger; pub mod vfs; pub mod watchdog; +pub use agents::{ + AGENTS_MODULE_NAME, AgentCallError, AgentInfo, AgentOutcome, AgentProvider, AgentRequest, + AgentUsage, +}; pub use call_log::{BodyCopy, CallOutcome, CallRecord, ModelUsage, PayloadRecord}; pub use decision::{ CallSite, CallTicket, DecisionAction, DecisionCause, DecisionExplanation, DecisionLog, @@ -73,6 +79,7 @@ pub use session_kv::{ InMemorySessionKv, SessionKvEntry, SessionKvError, SessionKvLimitKind, SessionKvLimits, SessionKvPage, SessionKvStore, SharedKvBudget, }; +pub use skills::{SKILLS_MODULE_NAME, Skill, SkillError, SkillInfo, SkillProvider}; pub use vfs::{ Access, CopyDirError, MAX_MEASURED_DEPTH, MountError, MountSpec, Vfs, VfsMode, copy_host_dir, copy_host_subdir, measure_dir, measure_host_dir, measure_host_dir_skipping_vanished, @@ -154,6 +161,14 @@ pub struct StoreData { /// becoming per-execution scratch state that no later `execute` can read — /// the guest surface reports that as a configuration error. pub session_kv: Option>, + /// The harness `submilli:agents` runs sub-agents through, present only when + /// the embedder wires one. `None` makes every call a catchable + /// [`AgentCallError::NotConfigured`]. + pub agent_provider: Option>, + /// The harness `submilli:skills` reads skills through, present only when the + /// embedder wires one. `None` makes every call a catchable + /// [`SkillError::NotConfigured`]. + pub skill_provider: Option>, /// Embedder sink for host-operation metrics (HTTP transport latencies). /// Defaults to [`NoopMetricsSink`]; the server installs a Sentry-backed one. pub metrics: Arc, @@ -270,6 +285,8 @@ impl StoreData { embedding_provider: None, embedding_budget: None, session_kv: None, + agent_provider: None, + skill_provider: None, metrics: Arc::new(metrics::NoopMetricsSink), tenant_limits: TenantLimits::new(max_store_bytes), host_fuel: 0, diff --git a/crates/interpreter/src/runtime/skills.rs b/crates/interpreter/src/runtime/skills.rs new file mode 100644 index 000000000..c1b72f6f2 --- /dev/null +++ b/crates/interpreter/src/runtime/skills.rs @@ -0,0 +1,97 @@ +//! The embedder-supplied seam for `submilli:skills`: a program reads the skills +//! the harness offers, their instructions and the files bundled with them. +//! +//! Where skills come from is the harness's choice. Everything that crosses +//! [`SkillProvider`] is owned, serializable data, so a harness may implement it +//! in process or forward it over the wire. + +use std::future::Future; +use std::pin::Pin; + +use serde::{Deserialize, Serialize}; + +pub const SKILLS_MODULE_NAME: &str = "submilli:skills"; + +/// One skill, as a listing shows it. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct SkillInfo { + pub name: String, + /// What the skill is for. The engine reduces it to one bounded line before a + /// program sees it in a listing. + pub description: Option, +} + +/// A loaded skill. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct Skill { + pub name: String, + pub description: Option, + /// The skill's instructions. + pub content: String, +} + +/// Why a skill or one of its files could not be read. Every message is safe to +/// show the program. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub enum SkillError { + /// No [`SkillProvider`] is wired into the runtime. + NotConfigured, + /// The harness has no skill of this name. + NotFound { name: String }, + /// The skill has no file at this path. + FileNotFound { name: String, path: String }, + /// The path is not a relative path inside the skill. The engine refuses + /// these before asking the provider; a provider may refuse more. + InvalidPath { path: String }, + /// Reading failed for another reason. `message` is a fixed classification + /// chosen by the provider. + Failed { message: String }, +} + +impl std::fmt::Display for SkillError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::NotConfigured => write!( + f, + "no skill provider is configured: this harness does not offer skills" + ), + Self::NotFound { name } => write!( + f, + "no skill named `{name}`; call `list()` for the skills you may load" + ), + Self::FileNotFound { name, path } => { + write!(f, "skill `{name}` has no file `{path}`") + } + Self::InvalidPath { path } => write!( + f, + "`{path}` is not a path inside a skill: use a relative path without `.` or `..` segments" + ), + Self::Failed { message } => write!(f, "{message}"), + } + } +} + +impl std::error::Error for SkillError {} + +/// The harness side of `submilli:skills`. +pub trait SkillProvider: Send + Sync { + /// Every skill the harness offers. The engine removes the ones the policy + /// denies to the caller before the program sees the list. + fn list<'a>( + &'a self, + ) -> Pin, SkillError>> + Send + 'a>>; + + /// The skill named `name`. + fn load<'a>( + &'a self, + name: &'a str, + ) -> Pin> + Send + 'a>>; + + /// The text of the file at `path` inside skill `name`. `path` is relative, + /// uses `/` separators and has no empty, `.` or `..` segment. + fn read_file<'a>( + &'a self, + name: &'a str, + path: &'a str, + ) -> Pin> + Send + 'a>>; +} diff --git a/crates/interpreter/src/span.rs b/crates/interpreter/src/span.rs index d3b43eb9c..30501e49b 100644 --- a/crates/interpreter/src/span.rs +++ b/crates/interpreter/src/span.rs @@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize}; pub struct FileId(pub u32); impl FileId { - pub const FIRST_RESERVED: u32 = u32::MAX - 22; + pub const FIRST_RESERVED: u32 = u32::MAX - 24; pub const COMPILER: FileId = FileId(Self::FIRST_RESERVED); pub const PRELUDE: FileId = FileId(u32::MAX); @@ -39,6 +39,8 @@ impl FileId { pub const EMBEDDING: FileId = FileId(u32::MAX - 21); pub const CODE: FileId = FileId(u32::MAX - 20); pub const GIT: FileId = FileId(u32::MAX - 19); + pub const AGENTS: FileId = FileId(u32::MAX - 22); + pub const SKILLS: FileId = FileId(u32::MAX - 23); /// Virtual display path for a reserved (prelude/stdlib) id, e.g. /// `submilli:fs`. Returns `None` for ordinary user/script files, which @@ -67,6 +69,8 @@ impl FileId { FileId::SECRETS => "submilli:secrets", FileId::SESSION => "submilli:session", FileId::LLM => "submilli:llm", + FileId::AGENTS => "submilli:agents", + FileId::SKILLS => "submilli:skills", FileId::TEST => "submilli:test", _ => return None, }) diff --git a/crates/interpreter/src/stdlib/agents/declaration.rs b/crates/interpreter/src/stdlib/agents/declaration.rs new file mode 100644 index 000000000..db5cd4825 --- /dev/null +++ b/crates/interpreter/src/stdlib/agents/declaration.rs @@ -0,0 +1,159 @@ +//! Type surface of `submilli:agents`. +//! +//! `run` is declared generic and typed the way `llm.call` is: the typechecker +//! matches it by mangled name ([`is_checked_run`]), fills the trailing `schema` +//! parameter with the JSON Schema emitted from `T`, and wraps the result in a +//! structural check against `T`. Without a type argument `T` is `string`, the +//! agent's final answer as text. See `stdlib/llm/declaration.rs` for why the +//! generic declaration is sound only together with that interception. + +use std::collections::BTreeMap; + +use crate::{ + Dispatch, PackageDeclaration, Param, PropertySig, Span, Type, TypeKind, TypeSymbol, ValueKind, + ValueSymbol, +}; + +use super::MODULE_NAME; + +const RUN: &str = "run"; +const RUN_TYPE_PARAM: &str = "T"; + +/// Whether `mangled` is the typed `run`, so the typechecker's interception +/// matches however the symbol was imported. +pub fn is_checked_run(mangled: &crate::MangledName) -> bool { + *mangled == crate::mangle::package_symbol(MODULE_NAME, RUN) +} + +pub fn package_declaration() -> PackageDeclaration { + let mut defs = PackageDeclaration::with_package(MODULE_NAME); + insert_agent_info_interface(&mut defs); + insert_fn( + &mut defs, + RUN, + vec![RUN_TYPE_PARAM.to_string()], + vec![ + Param::new("agent", Type::String), + Param::new("input", Type::String), + Param::with_default( + "schema", + Type::union(vec![Type::String, Type::Undefined]), + crate::DefaultValue::Undefined, + ), + ], + Type::TypeVar(RUN_TYPE_PARAM.to_string()), + "/**\n * Hand `input` to the sub-agent `agent` and return its final answer.\n *\n \ + * Without a type argument the answer is the agent's text. With one — \ + `run(agent, input)` — a JSON Schema for `T` is emitted at compile time \ + and sent with the task, and the answer is then checked structurally against \ + `T`. An answer that is not JSON, or does not match, throws a catchable \ + `TypeError`; nothing is coerced.\n *\n * `T` must be a type the schema can \ + carry: no functions, no `bigint`, no `Uint8Array`, no `unknown`, and no \ + recursive type.\n *\n * The harness runs the agent and decides how long it may \ + take and what it may spend. A run that fails, is cancelled, or names an agent \ + the harness does not have throws a catchable error; so does a runtime with no \ + agent provider.\n * @param agent Agent name. Call `list()` for the agents you \ + may use.\n * @param input The task, as text.\n * @capability agent.run { agent: \ + $agent }\n */", + ); + insert_fn( + &mut defs, + "list", + Vec::new(), + Vec::new(), + Type::Array(Box::new(agent_info_type())), + "/**\n * The agents this caller may hand work to.\n *\n * Each agent the harness \ + offers is filtered under `agent.run` by the same `agent` filter that gates \ + `run`, so the list never offers an agent the caller would be denied. Nothing \ + in it reveals how many were filtered out.\n *\n * Treat `description` as \ + advice: it is operator-authored text.\n * @capability agent.run\n */", + ); + defs +} + +fn agent_info_type() -> Type { + Type::InterfaceRef { + mangled: crate::mangle::package_symbol(MODULE_NAME, "AgentInfo"), + package: crate::Package(MODULE_NAME.to_string()), + name: "AgentInfo".to_string(), + args: Vec::new(), + } +} + +fn insert_agent_info_interface(defs: &mut PackageDeclaration) { + let mut properties = BTreeMap::new(); + insert_property( + &mut properties, + "name", + Type::String, + "/** The agent name, exactly as `run` expects it. */", + ); + insert_property( + &mut properties, + "description", + Type::union(vec![Type::String, Type::Undefined]), + "/** What the agent is for, or `undefined` when the harness gives none. Operator-authored advice, always a single line within a fixed length bound. */", + ); + defs.types.insert( + "AgentInfo".to_string(), + TypeSymbol { + name: "AgentInfo".to_string(), + mangled_name: crate::mangle::package_symbol(MODULE_NAME, "AgentInfo"), + declaration_span: Span::at(crate::FileId::AGENTS), + kind: TypeKind::Interface { + index: None, + generics: Vec::new(), + methods: BTreeMap::new(), + properties, + dispatch: Dispatch::Direct, + doc: crate::doc( + crate::FileId::AGENTS, + "/** One agent this caller may hand work to. Constructed only by `list()`. */", + ), + }, + }, + ); +} + +fn insert_property( + properties: &mut BTreeMap, + name: &str, + ty: Type, + doc: &str, +) { + properties.insert( + name.to_string(), + PropertySig { + ty, + readonly: true, + optional: false, + intrinsic: false, + doc: crate::doc(crate::FileId::AGENTS, doc), + }, + ); +} + +fn insert_fn( + defs: &mut PackageDeclaration, + name: &str, + generics: Vec, + params: Vec, + ret: Type, + doc: &str, +) { + defs.values.insert( + name.to_string(), + ValueSymbol { + name: name.to_string(), + mangled_name: crate::mangle::package_symbol(MODULE_NAME, name), + declaration_span: Span::at(crate::FileId::AGENTS), + kind: ValueKind::Function { + generics, + params, + ret, + type_predicate: None, + doc: crate::doc(crate::FileId::AGENTS, doc), + }, + }, + ); +} diff --git a/crates/interpreter/src/stdlib/agents/mod.rs b/crates/interpreter/src/stdlib/agents/mod.rs new file mode 100644 index 000000000..f42aa857d --- /dev/null +++ b/crates/interpreter/src/stdlib/agents/mod.rs @@ -0,0 +1,306 @@ +//! `submilli:agents` — hand work to a sub-agent from inside a Submilli program. +//! +//! An optional package: it exists only for an embedder that enables +//! [`OptionalPackage::Agents`](crate::stdlib::OptionalPackage::Agents). The +//! harness runs the agents through [`StoreData::agent_provider`]; a runtime with +//! none refuses every op with a catchable error rather than inventing an answer. +//! +//! **One capability.** `run` and `list()` are both `agent.run`, filtered by +//! `agent`. `list()` gates each candidate with the same filter, so a listing +//! never offers an agent the caller would be denied — the `llm.models()` shape. +//! +//! **No input or output in metadata.** The filter context is the agent name +//! only; the task and the answer reach the call log as payload bodies, never in +//! an error or a policy context. + +pub mod declaration; + +use std::sync::Arc; + +use wasmtime::{FuncType, HeapType, Linker, RefType, StructType, Val, ValType}; + +use crate::runtime::StoreData; +use crate::runtime::agents::{ + AgentCallError, AgentInfo, AgentOutcome, AgentProvider, AgentRequest, +}; +use crate::runtime::call_log::{ModelUsage, Payload, Side, record_payload, record_usage}; +use crate::runtime::decision::CallTicket; +use crate::runtime::fuel; +use crate::runtime::host::{ + abi_arg, abi_result, read_string_arg, register_host_fn_async, write_submilli_string_struct, +}; +use crate::runtime::intrinsic_types::build_intrinsic_types; +use crate::stdlib::abi::{ + self, backing_struct, install_field_getters, nullable_object_field, string_field, +}; +use crate::stdlib::shared::{ + check_security_call, filters_candidate, mark_filtered, preflight_listing, running_package, + sanitize_description, +}; + +pub use declaration::package_declaration; + +pub const MODULE_NAME: &str = crate::runtime::agents::AGENTS_MODULE_NAME; + +/// The capability gating every op in this package. +pub const CAPABILITY: &str = "agent.run"; + +// `$AgentInfoBacking` field indices (0 is the vtable). +const A_NAME: usize = 1; +const A_DESCRIPTION: usize = 2; + +pub fn install(linker: &mut Linker) -> wasmtime::Result<()> { + let engine = linker.engine().clone(); + let intr = build_intrinsic_types(&engine)?; + let string = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.string.clone()), + )); + let nullable_object = ValType::Ref(RefType::new( + true, + HeapType::ConcreteStruct(intr.object.clone()), + )); + let array = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.array.clone()), + )); + + register_host_fn_async( + linker, + MODULE_NAME, + crate::mangle::package_symbol(MODULE_NAME, "run"), + FuncType::new( + &engine, + [string.clone(), string.clone(), nullable_object.clone()], + // `run` is generic, so its result travels in the erased `T` slot. + [nullable_object.clone()], + ), + /* deterministic = */ false, + |caller, params, results| { + Box::pin(async move { + let agent = + read_string_arg(&mut *caller, abi_arg(params, 0)?, "agents.run (agent)")?; + let input = + read_string_arg(&mut *caller, abi_arg(params, 1)?, "agents.run (input)")?; + let schema = read_optional_string(caller, abi_arg(params, 2)?)?; + let result = abi_result(results, 0)?; + *result = run(caller, agent, input, schema).await?; + Ok(()) + }) + }, + )?; + + register_host_fn_async( + linker, + MODULE_NAME, + crate::mangle::package_symbol(MODULE_NAME, "list"), + FuncType::new(&engine, [], [array]), + /* deterministic = */ false, + |caller, _params, results| { + Box::pin(async move { + *abi_result(results, 0)? = list(caller).await?; + Ok(()) + }) + }, + )?; + + let receiver = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.object.clone()), + )); + install_field_getters( + linker, + MODULE_NAME, + "AgentInfo", + &engine, + &receiver, + &[ + ("name", A_NAME, string), + ("description", A_DESCRIPTION, nullable_object), + ], + ) +} + +/// One run: gate, record, dispatch, then build the result without refusing for +/// fuel, because the run has already happened. +async fn run( + caller: &mut wasmtime::Caller<'_, StoreData>, + agent: String, + input: String, + schema: Option, +) -> wasmtime::Result { + let ticket = gate(caller, &agent)?; + let sent = (input.len() + schema.as_deref().map_or(0, str::len)) as u64; + record_payload(&*caller, ticket, Side::Request, || { + Payload::meta(serde_json::json!({ "op": "run", "agent": agent, "schema": schema })) + .with_owned_body(input.clone().into_bytes()) + .with_size(sent) + }); + let provider = provider(caller, "run")?; + fuel::charge(&mut *caller, fuel::IO, sent)?; + let principal = running_package(caller).map_err(|error| error.into_denial(CAPABILITY))?; + let typed = schema.is_some(); + let request = AgentRequest { + agent: agent.clone(), + input, + schema, + caller: principal, + }; + match provider.run(request).await { + Ok(outcome) => { + record_outcome(caller, ticket, &outcome); + fuel::settle(&mut *caller, fuel::IO, outcome.text.len() as u64)?; + fuel::settle_result(caller, |caller| { + if typed { + crate::runtime::json::parse_json_as_unknown( + caller, + &outcome.text, + &format!("agents.run(\"{agent}\"): the agent's result is not JSON"), + ) + } else { + let text = write_submilli_string_struct(caller, &outcome.text)?; + Ok(Val::AnyRef(Some(text.to_anyref()))) + } + }) + } + Err(error) => { + record_payload(&*caller, ticket, Side::Response, || { + Payload::meta(serde_json::json!({ "call_error": call_error_record(&error) })) + }); + Err(throw("run", &error)) + } + } +} + +fn record_outcome( + caller: &wasmtime::Caller<'_, StoreData>, + ticket: Option, + outcome: &AgentOutcome, +) { + let usage = outcome.usage.clone().unwrap_or_default(); + record_payload(caller, ticket, Side::Response, || { + Payload::meta(serde_json::json!({ + "usage": { + "input_tokens": usage.input_tokens, + "output_tokens": usage.output_tokens, + } + })) + .with_owned_body(outcome.text.clone().into_bytes()) + .with_size(outcome.text.len() as u64) + }); + record_usage( + caller, + ticket, + ModelUsage { + input_tokens: usage.input_tokens, + output_tokens: usage.output_tokens, + }, + ); +} + +/// The capability check, run before anything reaches the harness. The context +/// is the agent name only: a policy can choose which agents a caller reaches, +/// not read the task. +fn gate( + caller: &mut wasmtime::Caller<'_, StoreData>, + agent: &str, +) -> wasmtime::Result> { + check_security_call(caller, CAPABILITY, serde_json::json!({ "agent": agent })) +} + +/// `list()`: every agent the harness offers that the caller may run. A denied +/// candidate is left out, never reported. +async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result { + preflight_listing(caller, CAPABILITY, &serde_json::json!({ "agent": "" }))?; + let provider = provider(caller, "list")?; + let candidates = provider.agents().await.map_err(|e| throw("list", &e))?; + let mut visible = Vec::new(); + for candidate in candidates { + let keeps = filters_candidate(gate(caller, &candidate.name).map(|_| ()))?; + if keeps { + visible.push(candidate); + } else { + mark_filtered(&*caller); + } + } + let mut built = Vec::with_capacity(visible.len()); + for agent in visible { + built.push(build_agent_info(caller, agent)?); + } + abi::new_array(caller, &built) +} + +/// Clone the provider out of the store before any `await`. Runs after the +/// capability check, so a denied caller cannot learn whether a harness is wired. +fn provider( + caller: &wasmtime::Caller<'_, StoreData>, + op: &str, +) -> wasmtime::Result> { + caller + .data() + .agent_provider + .clone() + .ok_or_else(|| throw(op, &AgentCallError::NotConfigured)) +} + +fn throw(op: &str, error: &AgentCallError) -> wasmtime::Error { + wasmtime::Error::msg(format!("agents.{op}: {error}")) +} + +/// A run's failure as the call log keeps it: a stable kind and the agent. +fn call_error_record(error: &AgentCallError) -> serde_json::Value { + match error { + AgentCallError::NotConfigured => serde_json::json!({ "kind": "not-configured" }), + AgentCallError::NotFound { agent } => { + serde_json::json!({ "kind": "not-found", "agent": agent }) + } + AgentCallError::Failed { agent, message } => { + serde_json::json!({ "kind": "failed", "agent": agent, "message": message }) + } + AgentCallError::Cancelled { agent } => { + serde_json::json!({ "kind": "cancelled", "agent": agent }) + } + } +} + +/// Read the compiler-filled `schema` argument. Undefined means an untyped call. +fn read_optional_string( + caller: &mut wasmtime::Caller<'_, StoreData>, + val: &Val, +) -> wasmtime::Result> { + if crate::runtime::prelude::undefined::is_undefined(caller, val)? { + return Ok(None); + } + read_string_arg(caller, val, "agents.run (schema)").map(Some) +} + +fn agent_info_backing_struct(engine: &wasmtime::Engine) -> wasmtime::Result { + let intr = build_intrinsic_types(engine)?; + backing_struct( + engine, + &intr, + vec![ + string_field(&intr), // name + nullable_object_field(&intr), // description + ], + ) +} + +fn build_agent_info( + caller: &mut wasmtime::Caller<'_, StoreData>, + agent: AgentInfo, +) -> wasmtime::Result { + let name = write_submilli_string_struct(caller, &agent.name)?; + let description = match agent.description.as_deref().and_then(sanitize_description) { + Some(text) => Val::AnyRef(Some( + write_submilli_string_struct(caller, &text)?.to_anyref(), + )), + None => crate::runtime::prelude::undefined::value(caller)?, + }; + let ty = agent_info_backing_struct(caller.engine())?; + abi::new_backing( + caller, + ty, + &[Val::AnyRef(Some(name.to_anyref())), description], + ) +} diff --git a/crates/interpreter/src/stdlib/capabilities.rs b/crates/interpreter/src/stdlib/capabilities.rs index e5def1385..0829eb00a 100644 --- a/crates/interpreter/src/stdlib/capabilities.rs +++ b/crates/interpreter/src/stdlib/capabilities.rs @@ -523,9 +523,46 @@ const CORE_CATALOG: &[CapabilityGroup] = &[ }, ]; +const AGENT: FilterField = field( + "agent", + "string", + "The sub-agent's name, as `submilli:agents` list() names it", +); + +const AGENTS: CapabilityGroup = CapabilityGroup { + module: "submilli:agents", + capabilities: &[Capability { + name: "agent.run", + main_denial: None, + summary: "Hand work to a harness sub-agent, or list the agents", + filter_fields: &[AGENT], + example_filter: "agent == \"researcher\"", + }], +}; + +const SKILL: FilterField = field( + "name", + "string", + "The skill's name, as `submilli:skills` list() names it", +); + +const SKILLS: CapabilityGroup = CapabilityGroup { + module: "submilli:skills", + capabilities: &[Capability { + name: "skill.load", + main_denial: None, + summary: "Load a harness skill, read its files, or list the skills", + filter_fields: &[SKILL], + example_filter: "name == \"code-review\"", + }], +}; + /// The capabilities of one optional package. fn optional_group(package: OptionalPackage) -> &'static CapabilityGroup { - match package {} + match package { + OptionalPackage::Agents => &AGENTS, + OptionalPackage::Skills => &SKILLS, + } } /// Every capability the core packages gate, grouped by source module. An diff --git a/crates/interpreter/src/stdlib/mod.rs b/crates/interpreter/src/stdlib/mod.rs index b8f3ca2cc..0bb99dcd3 100644 --- a/crates/interpreter/src/stdlib/mod.rs +++ b/crates/interpreter/src/stdlib/mod.rs @@ -9,6 +9,7 @@ //! vtables separately for each store. pub(crate) mod abi; +pub mod agents; pub mod capabilities; pub mod code; pub mod crypto; @@ -22,6 +23,7 @@ pub mod secrets; pub mod security; pub mod session; pub mod shared; +pub mod skills; /// Test-authoring package. Deliberately absent from /// [`stdlib_package_declarations`] and [`install_host_functions`]: only /// `submilli build test` makes it importable (by passing its declaration into @@ -33,8 +35,8 @@ pub mod uuid; use wasmtime::Linker; -use crate::PackageDeclaration; use crate::runtime::StoreData; +use crate::{MangledName, PackageDeclaration, Type}; /// A standard-library package that exists only when the embedder provides it. /// @@ -44,13 +46,21 @@ use crate::runtime::StoreData; /// functions are not installed. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] #[non_exhaustive] -pub enum OptionalPackage {} +pub enum OptionalPackage { + /// `submilli:agents`, backed by [`AgentProvider`](crate::runtime::AgentProvider). + Agents, + /// `submilli:skills`, backed by [`SkillProvider`](crate::runtime::SkillProvider). + Skills, +} impl OptionalPackage { - pub const ALL: &'static [OptionalPackage] = &[]; + pub const ALL: &'static [OptionalPackage] = &[Self::Agents, Self::Skills]; pub const fn module_name(self) -> &'static str { - match self {} + match self { + Self::Agents => agents::MODULE_NAME, + Self::Skills => skills::MODULE_NAME, + } } pub fn from_module_name(name: &str) -> Option { @@ -61,18 +71,88 @@ impl OptionalPackage { } fn package_declaration(self) -> PackageDeclaration { - match self {} + match self { + Self::Agents => agents::package_declaration(), + Self::Skills => skills::package_declaration(), + } } - fn install(self, _linker: &mut Linker) -> wasmtime::Result<()> { - match self {} + fn install(self, linker: &mut Linker) -> wasmtime::Result<()> { + match self { + Self::Agents => agents::install(linker), + Self::Skills => skills::install(linker), + } } const fn bit(self) -> u8 { - match self {} + match self { + Self::Agents => 1, + Self::Skills => 1 << 1, + } } } +/// A host call the typechecker types from its type argument: the compiler emits +/// a JSON Schema for `T` into the call's trailing `schema` parameter and wraps +/// the result in a structural check against `T`. What differs between such +/// calls is what a bare call returns and how diagnostics name it. +pub(crate) struct SchemaCheckedCall { + /// The call as diagnostics name it, e.g. `llm.call`. + pub callee: &'static str, + /// A typed call to show in a diagnostic. + pub example: &'static str, + /// What the structural check is applied to. + pub checks: &'static str, + /// Who the schema is sent to. + pub answerer: &'static str, + /// The arguments a program writes, in prose. + pub written: &'static str, + pub written_count: usize, + /// The ordinal of the schema argument, in prose. + pub extra_argument: &'static str, + /// How to do without a type argument, in three phrasings. + pub untyped_read: &'static str, + pub untyped_unknown: &'static str, + pub untyped_parse: &'static str, + /// What `T` binds to when the program wrote no type argument. + pub untyped_result: Type, +} + +/// The schema-checked call `mangled` names, if it is one. +pub(crate) fn schema_checked_call(mangled: &MangledName) -> Option { + if llm::declaration::is_checked_call(mangled) { + return Some(SchemaCheckedCall { + callee: "llm.call", + example: "llm.call(model, prompt)", + checks: "the model's response", + answerer: "the model", + written: "the model and the prompt", + written_count: 2, + extra_argument: "third", + untyped_read: "read the `Completion` envelope yourself", + untyped_unknown: "read the `Completion` envelope's `ok` and `text` yourself", + untyped_parse: "parse the `Completion` text yourself", + untyped_result: llm::declaration::untyped_result_type(mangled), + }); + } + if agents::declaration::is_checked_run(mangled) { + return Some(SchemaCheckedCall { + callee: "agents.run", + example: "agents.run(agent, input)", + checks: "the agent's result", + answerer: "the agent", + written: "the agent and the input", + written_count: 2, + extra_argument: "third", + untyped_read: "read the returned text yourself", + untyped_unknown: "read the returned text yourself", + untyped_parse: "parse the returned text yourself", + untyped_result: Type::String, + }); + } + None +} + /// The standard library an embedder offers its programs: the core packages /// every embedder has, plus the [`OptionalPackage`]s it enables. /// @@ -216,6 +296,9 @@ pub(crate) fn install_store_bound( git::class::install(linker, store) } +#[cfg(test)] +mod optional_tests; + #[cfg(test)] mod tests { use super::*; diff --git a/crates/interpreter/src/stdlib/optional_tests.rs b/crates/interpreter/src/stdlib/optional_tests.rs new file mode 100644 index 000000000..56f0415b0 --- /dev/null +++ b/crates/interpreter/src/stdlib/optional_tests.rs @@ -0,0 +1,511 @@ +//! `submilli:agents` and `submilli:skills` end to end: a program compiled and run +//! under a [`Stdlib`] that enables them, against fake providers. + +use std::future::Future; +use std::pin::Pin; +use std::sync::{Arc, Mutex}; + +use crate::runtime::agents::{ + AgentCallError, AgentInfo, AgentOutcome, AgentProvider, AgentRequest, AgentUsage, +}; +use crate::runtime::skills::{Skill, SkillError, SkillInfo, SkillProvider}; +use crate::runtime::{ + CheckOutcome, RuntimeConfig, SecurityCheck, StoreData, Vfs, dispatch_main_async, + install_runtime_async_for, +}; +use crate::stdlib::{OptionalPackage, Stdlib, capabilities}; + +type Boxed<'a, T> = Pin + Send + 'a>>; + +fn harness_stdlib() -> Stdlib { + Stdlib::core() + .with(OptionalPackage::Agents) + .with(OptionalPackage::Skills) +} + +/// Answers every run with `answer` and records what it was asked. +struct FakeAgents { + answer: Result, + requests: Mutex>, +} + +impl FakeAgents { + fn answering(answer: &str) -> Arc { + Arc::new(Self { + answer: Ok(answer.to_string()), + requests: Mutex::new(Vec::new()), + }) + } + + fn failing(error: AgentCallError) -> Arc { + Arc::new(Self { + answer: Err(error), + requests: Mutex::new(Vec::new()), + }) + } + + fn requests(&self) -> Vec { + self.requests.lock().expect("requests").clone() + } +} + +impl AgentProvider for FakeAgents { + fn run<'a>(&'a self, request: AgentRequest) -> Boxed<'a, Result> { + self.requests.lock().expect("requests").push(request); + let answer = self.answer.clone(); + Box::pin(async move { + answer.map(|text| AgentOutcome { + text, + usage: Some(AgentUsage { + input_tokens: Some(3), + output_tokens: None, + }), + }) + }) + } + + fn agents<'a>(&'a self) -> Boxed<'a, Result, AgentCallError>> { + Box::pin(async { + Ok(vec![ + AgentInfo { + name: "researcher".to_string(), + description: Some("Finds\nsources".to_string()), + }, + AgentInfo { + name: "deployer".to_string(), + description: None, + }, + ]) + }) + } +} + +/// Two skills; `review` bundles one file. +struct FakeSkills { + reads: Mutex>, +} + +impl FakeSkills { + fn new() -> Arc { + Arc::new(Self { + reads: Mutex::new(Vec::new()), + }) + } +} + +impl SkillProvider for FakeSkills { + fn list<'a>(&'a self) -> Boxed<'a, Result, SkillError>> { + Box::pin(async { + Ok(vec![ + SkillInfo { + name: "review".to_string(), + description: Some("Review a diff".to_string()), + }, + SkillInfo { + name: "internal".to_string(), + description: None, + }, + ]) + }) + } + + fn load<'a>(&'a self, name: &'a str) -> Boxed<'a, Result> { + Box::pin(async move { + match name { + "review" => Ok(Skill { + name: "review".to_string(), + description: Some("Review a diff".to_string()), + content: "Read the diff twice.".to_string(), + }), + _ => Err(SkillError::NotFound { + name: name.to_string(), + }), + } + }) + } + + fn read_file<'a>( + &'a self, + name: &'a str, + path: &'a str, + ) -> Boxed<'a, Result> { + self.reads + .lock() + .expect("reads") + .push((name.to_string(), path.to_string())); + Box::pin(async move { + match (name, path) { + ("review", "templates/report.md") => Ok("# Report".to_string()), + _ => Err(SkillError::FileNotFound { + name: name.to_string(), + path: path.to_string(), + }), + } + }) + } +} + +/// Denies `capability` calls whose context field `field` equals `value`, and +/// records every context it is asked about. +struct DenyOne { + field: &'static str, + value: &'static str, + contexts: Mutex>, +} + +impl DenyOne { + fn new(field: &'static str, value: &'static str) -> Arc { + Arc::new(Self { + field, + value, + contexts: Mutex::new(Vec::new()), + }) + } +} + +impl SecurityCheck for DenyOne { + fn check(&self, _caller: &str, _capability: &str, context: &serde_json::Value) -> CheckOutcome { + self.contexts + .lock() + .expect("contexts") + .push(context.clone()); + if context[self.field] == self.value { + CheckOutcome::Deny { + rule: None, + reason: format!("policy denies {}", self.value), + } + } else { + CheckOutcome::Allow { rule: None } + } + } +} + +#[derive(Default)] +struct Harness { + agents: Option>, + skills: Option>, + policy: Option>, +} + +impl Harness { + fn agents(mut self, agents: Arc) -> Self { + self.agents = Some(agents); + self + } + + fn skills(mut self, skills: Arc) -> Self { + self.skills = Some(skills); + self + } + + fn policy(mut self, policy: Arc) -> Self { + self.policy = Some(policy); + self + } + + /// Compile `source` under the harness set and run it; `main`'s result. + async fn run(self, source: &str) -> wasmtime::Result { + let stdlib = harness_stdlib(); + let parsed = crate::parse_script(source, crate::FileId(0)); + let compiled = crate::compile_parsed_script_timed( + source, + "test.ts", + &parsed, + &stdlib.package_declarations(), + &[], + &[], + ) + .expect("compile clean"); + let cfg = RuntimeConfig::default(); + let engine = cfg.engine().expect("engine"); + let mut data = StoreData::with_vfs(Vfs::tempdir().expect("tempdir")); + data.install_type_info(compiled.type_info.clone()); + data.agent_provider = self.agents; + data.skill_provider = self.skills; + if let Some(policy) = self.policy { + data.security_check = policy; + } + let mut store = cfg.store_async(&engine, data).expect("store"); + let module = wasmtime::Module::new(&engine, &compiled.wasm).expect("module"); + let mut linker = wasmtime::Linker::::new(&engine); + install_runtime_async_for(&mut linker, &mut store, stdlib) + .await + .expect("install"); + let inst = linker + .instantiate_async(&mut store, &module) + .await + .expect("instantiate"); + dispatch_main_async(&mut store, &inst) + .await + .map(Option::unwrap_or_default) + } +} + +fn compile_errors(source: &str, stdlib: Stdlib) -> Vec { + let parsed = crate::parse_script(source, crate::FileId(0)); + match crate::compile_parsed_script_timed( + source, + "test.ts", + &parsed, + &stdlib.package_declarations(), + &[], + &[], + ) { + Ok(_) => Vec::new(), + Err(diagnostics) => diagnostics + .into_iter() + .map(|d| format!("{} {}", d.message, d.help.join(" "))) + .collect(), + } +} + +#[test] +fn a_disabled_package_is_not_available_in_this_harness() { + for module in ["submilli:agents", "submilli:skills"] { + let source = + format!("import {{ list }} from \"{module}\";\nfunction main(): void {{ list(); }}\n"); + let errors = compile_errors(&source, Stdlib::core()); + assert!( + errors + .iter() + .any(|e| e.contains(&format!("`{module}` is not available in this harness"))), + "{errors:?}" + ); + let parsed = crate::parse_script(&source, crate::FileId(0)); + let imports = parsed.external_imports().expect("imports"); + assert!( + imports.stdlib.contains(module), + "{module} is stdlib, not a registry package" + ); + assert!(imports.registry_packages.is_empty()); + } +} + +#[test] +fn only_an_enabling_set_discovers_and_catalogs_the_packages() { + let core_modules: Vec = crate::packages::search("") + .into_iter() + .map(|m| m.name) + .collect(); + let harness_modules: Vec = harness_stdlib() + .search("") + .into_iter() + .map(|m| m.name) + .collect(); + for module in ["submilli:agents", "submilli:skills"] { + assert!( + !core_modules.iter().any(|m| m == module), + "{core_modules:?}" + ); + assert!( + harness_modules.iter().any(|m| m == module), + "{harness_modules:?}" + ); + assert!(crate::packages::docs(module).is_none()); + assert!(harness_stdlib().docs(module).is_some()); + } + for capability in ["agent.run", "skill.load"] { + assert!(capabilities::find(capability).is_none()); + assert!(capabilities::find_in(harness_stdlib(), capability).is_some()); + } + let agents_only = Stdlib::core().with(OptionalPackage::Agents); + assert!(capabilities::find_in(agents_only, "agent.run").is_some()); + assert!(capabilities::find_in(agents_only, "skill.load").is_none()); +} + +#[test] +fn a_written_schema_argument_is_refused() { + let errors = compile_errors( + "import agents from \"submilli:agents\";\n\ + function main(): void { agents.run(\"researcher\", \"go\", \"{}\"); }\n", + harness_stdlib(), + ); + assert!( + errors + .iter() + .any(|e| e.contains("takes the agent and the input")), + "{errors:?}" + ); +} + +#[tokio::test] +async fn an_untyped_run_returns_the_agents_text() { + let agents = FakeAgents::answering("found three sources"); + let out = Harness::default() + .agents(agents.clone()) + .run( + r#"import agents from "submilli:agents"; + function main(): string { return agents.run("researcher", "find sources"); }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "found three sources"); + assert_eq!( + agents.requests(), + [AgentRequest { + agent: "researcher".to_string(), + input: "find sources".to_string(), + schema: None, + caller: "main".to_string(), + }] + ); +} + +#[tokio::test] +async fn a_typed_run_sends_a_schema_and_checks_the_answer() { + let agents = FakeAgents::answering(r#"{"score": 7, "summary": "fine"}"#); + let out = Harness::default() + .agents(agents.clone()) + .run( + r#"import agents from "submilli:agents"; + interface Review { score: number; summary: string } + function main(): string { + const review = agents.run("researcher", "review it"); + return review.summary + " " + String(review.score); + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "fine 7"); + let schema = agents.requests()[0].schema.clone().expect("a schema"); + assert!(schema.contains("\"score\""), "{schema}"); +} + +#[tokio::test] +async fn a_typed_run_throws_when_the_answer_does_not_match() { + let out = Harness::default() + .agents(FakeAgents::answering(r#"{"score": "high"}"#)) + .run( + r#"import agents from "submilli:agents"; + interface Review { score: number } + function main(): string { + try { + agents.run("researcher", "review it"); + return "accepted"; + } catch (e: TypeError) { + return "rejected"; + } + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "rejected"); +} + +#[tokio::test] +async fn a_denied_run_never_reaches_the_harness() { + let agents = FakeAgents::answering("deployed"); + let policy = DenyOne::new("agent", "deployer"); + let out = Harness::default() + .agents(agents.clone()) + .policy(policy.clone()) + .run( + r#"import agents from "submilli:agents"; + function main(): string { + try { + agents.run("deployer", "ship it"); + return "ran"; + } catch (e: PermissionDeniedError) { + return "denied"; + } + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "denied"); + assert!(agents.requests().is_empty()); + let contexts = policy.contexts.lock().expect("contexts").clone(); + assert_eq!(contexts, [serde_json::json!({ "agent": "deployer" })]); +} + +#[tokio::test] +async fn list_leaves_out_the_agents_the_caller_may_not_run() { + let out = Harness::default() + .agents(FakeAgents::answering("")) + .policy(DenyOne::new("agent", "deployer")) + .run( + r#"import agents from "submilli:agents"; + function main(): string { + return agents.list().map((a) => a.name + ":" + (a.description ?? "-")).join(","); + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "researcher:Finds sources"); +} + +#[tokio::test] +async fn harness_failures_and_a_missing_provider_are_catchable() { + let source = r#"import agents from "submilli:agents"; + function main(): string { + try { agents.run("researcher", "go"); return "ran"; } + catch (e) { return e.message; } + }"#; + let failed = Harness::default() + .agents(FakeAgents::failing(AgentCallError::Failed { + agent: "researcher".to_string(), + message: "step limit reached".to_string(), + })) + .run(source) + .await + .expect("program completes"); + assert_eq!( + failed, + "agents.run: agent `researcher` failed: step limit reached" + ); + + let unconfigured = Harness::default() + .run(source) + .await + .expect("program completes"); + assert!( + unconfigured.contains("no agent provider is configured"), + "{unconfigured}" + ); +} + +#[tokio::test] +async fn skills_list_load_and_read_files() { + let skills = FakeSkills::new(); + let out = Harness::default() + .skills(skills.clone()) + .policy(DenyOne::new("name", "internal")) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + const names = skills.list().map((s) => s.name).join(","); + const review = skills.load("review"); + const report = skills.readFile("review", "templates/report.md"); + return names + "|" + review.content + "|" + report; + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "review|Read the diff twice.|# Report"); +} + +#[tokio::test] +async fn read_file_is_gated_by_the_skill_and_refuses_paths_outside_it() { + let skills = FakeSkills::new(); + let out = Harness::default() + .skills(skills.clone()) + .policy(DenyOne::new("name", "internal")) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + let out = ""; + try { skills.readFile("internal", "SKILL.md"); out += "read "; } + catch (e: PermissionDeniedError) { out += "denied "; } + try { skills.readFile("review", "../secrets"); out += "escaped"; } + catch (e: RangeError) { out += "range"; } + return out; + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "denied range"); + assert!( + skills.reads.lock().expect("reads").is_empty(), + "neither call may reach the harness" + ); +} diff --git a/crates/interpreter/src/stdlib/shared.rs b/crates/interpreter/src/stdlib/shared.rs index 2b71fb9b6..629a45203 100644 --- a/crates/interpreter/src/stdlib/shared.rs +++ b/crates/interpreter/src/stdlib/shared.rs @@ -583,6 +583,20 @@ pub(crate) fn preflight_models( caller: &mut wasmtime::Caller<'_, StoreData>, capability: &str, count_field: &str, +) -> wasmtime::Result<()> { + preflight_listing( + caller, + capability, + &serde_json::json!({ "model": "", count_field: 0 }), + ) +} + +/// [`preflight_models`] for any listing filtered per candidate: `context` is what +/// an invariant denial is audited with, the context of an empty candidate. +pub(crate) fn preflight_listing( + caller: &mut wasmtime::Caller<'_, StoreData>, + capability: &str, + context: &serde_json::Value, ) -> wasmtime::Result<()> { fuel::charge_host_fuel(&mut *caller, fuel::GATE)?; running_package(caller).map(|_| ()).map_err(|error| { @@ -591,7 +605,7 @@ pub(crate) fn preflight_models( &*caller, unknown.label, capability, - &serde_json::json!({ "model": "", count_field: 0 }), + context, "invariant", unknown.reason, ); diff --git a/crates/interpreter/src/stdlib/skills/declaration.rs b/crates/interpreter/src/stdlib/skills/declaration.rs new file mode 100644 index 000000000..43b51b216 --- /dev/null +++ b/crates/interpreter/src/stdlib/skills/declaration.rs @@ -0,0 +1,158 @@ +//! Type surface of `submilli:skills`. + +use std::collections::BTreeMap; + +use crate::{ + Dispatch, PackageDeclaration, Param, PropertySig, Span, Type, TypeKind, TypeSymbol, ValueKind, + ValueSymbol, +}; + +use super::MODULE_NAME; + +pub fn package_declaration() -> PackageDeclaration { + let mut defs = PackageDeclaration::with_package(MODULE_NAME); + insert_interface( + &mut defs, + "SkillInfo", + skill_properties(false), + "/** One skill this caller may load. Constructed only by `list()`. */", + ); + insert_interface( + &mut defs, + "Skill", + skill_properties(true), + "/** A loaded skill: its instructions, and the name to read its files under. Constructed only by `load()`. */", + ); + insert_fn( + &mut defs, + "list", + Vec::new(), + Type::Array(Box::new(interface_type("SkillInfo"))), + "/**\n * The skills this caller may load.\n *\n * Each skill the harness offers is \ + filtered under `skill.load` by the same `name` filter that gates `load`, so \ + the list never offers a skill the caller would be denied. Nothing in it \ + reveals how many were filtered out.\n * @capability skill.load\n */", + ); + insert_fn( + &mut defs, + "load", + vec![Param::new("name", Type::String)], + interface_type("Skill"), + "/**\n * Load the skill `name`: its description and its instructions.\n *\n * \ + Throws a catchable error when the harness has no skill of that name, or when \ + this runtime has no skill provider.\n * @param name Skill name. Call `list()` \ + for the skills you may load.\n * @capability skill.load { name: $name }\n */", + ); + insert_fn( + &mut defs, + "readFile", + vec![ + Param::new("name", Type::String), + Param::new("path", Type::String), + ], + Type::String, + "/**\n * Read a file bundled with the skill `name`, as text.\n *\n * `path` is \ + relative to the skill, with `/` separators, as the skill's instructions name \ + it — `\"templates/report.md\"`. An absolute path, or one with an empty, `.` \ + or `..` segment, throws a `RangeError` without asking the harness; a file the \ + skill does not have throws a catchable error.\n * @param name Skill name.\n \ + * @param path The file's path inside the skill.\n * @capability skill.load { \ + name: $name }\n */", + ); + defs +} + +fn interface_type(name: &str) -> Type { + Type::InterfaceRef { + mangled: crate::mangle::package_symbol(MODULE_NAME, name), + package: crate::Package(MODULE_NAME.to_string()), + name: name.to_string(), + args: Vec::new(), + } +} + +/// `name` and `description`, plus `content` for a loaded skill. +fn skill_properties(loaded: bool) -> BTreeMap { + let mut properties = BTreeMap::new(); + insert_property( + &mut properties, + "name", + Type::String, + "/** The skill name, exactly as `load` and `readFile` expect it. */", + ); + insert_property( + &mut properties, + "description", + Type::union(vec![Type::String, Type::Undefined]), + "/** What the skill is for, or `undefined` when the harness gives none. */", + ); + if loaded { + insert_property( + &mut properties, + "content", + Type::String, + "/** The skill's instructions. */", + ); + } + properties +} + +fn insert_interface( + defs: &mut PackageDeclaration, + name: &str, + properties: BTreeMap, + doc: &str, +) { + defs.types.insert( + name.to_string(), + TypeSymbol { + name: name.to_string(), + mangled_name: crate::mangle::package_symbol(MODULE_NAME, name), + declaration_span: Span::at(crate::FileId::SKILLS), + kind: TypeKind::Interface { + index: None, + generics: Vec::new(), + methods: BTreeMap::new(), + properties, + dispatch: Dispatch::Direct, + doc: crate::doc(crate::FileId::SKILLS, doc), + }, + }, + ); +} + +fn insert_property( + properties: &mut BTreeMap, + name: &str, + ty: Type, + doc: &str, +) { + properties.insert( + name.to_string(), + PropertySig { + ty, + readonly: true, + optional: false, + intrinsic: false, + doc: crate::doc(crate::FileId::SKILLS, doc), + }, + ); +} + +fn insert_fn(defs: &mut PackageDeclaration, name: &str, params: Vec, ret: Type, doc: &str) { + defs.values.insert( + name.to_string(), + ValueSymbol { + name: name.to_string(), + mangled_name: crate::mangle::package_symbol(MODULE_NAME, name), + declaration_span: Span::at(crate::FileId::SKILLS), + kind: ValueKind::Function { + generics: Vec::new(), + params, + ret, + type_predicate: None, + doc: crate::doc(crate::FileId::SKILLS, doc), + }, + }, + ); +} diff --git a/crates/interpreter/src/stdlib/skills/mod.rs b/crates/interpreter/src/stdlib/skills/mod.rs new file mode 100644 index 000000000..1bcdfcde3 --- /dev/null +++ b/crates/interpreter/src/stdlib/skills/mod.rs @@ -0,0 +1,377 @@ +//! `submilli:skills` — read the skills a harness offers from inside a Submilli +//! program. +//! +//! An optional package: it exists only for an embedder that enables +//! [`OptionalPackage::Skills`](crate::stdlib::OptionalPackage::Skills). The +//! harness serves skills through [`StoreData::skill_provider`]; a runtime with +//! none refuses every op with a catchable error. +//! +//! **One capability.** `list()`, `load` and `readFile` are all `skill.load`, +//! filtered by `name`. `list()` gates each candidate with the same filter, so a +//! listing never offers a skill the caller would be denied. + +pub mod declaration; + +use std::sync::Arc; + +use wasmtime::{FuncType, HeapType, Linker, RefType, StructType, Val, ValType}; + +use crate::runtime::StoreData; +use crate::runtime::call_log::{Payload, Side, record_payload}; +use crate::runtime::decision::CallTicket; +use crate::runtime::fuel; +use crate::runtime::host::{ + abi_arg, abi_result, range_error, read_string_arg, register_host_fn_async, + write_submilli_string_struct, +}; +use crate::runtime::intrinsic_types::build_intrinsic_types; +use crate::runtime::skills::{Skill, SkillError, SkillInfo, SkillProvider}; +use crate::stdlib::abi::{ + self, backing_struct, install_field_getters, nullable_object_field, string_field, +}; +use crate::stdlib::shared::{ + check_security_call, filters_candidate, mark_filtered, preflight_listing, sanitize_description, +}; + +pub use declaration::package_declaration; + +pub const MODULE_NAME: &str = crate::runtime::skills::SKILLS_MODULE_NAME; + +/// The capability gating every op in this package. +pub const CAPABILITY: &str = "skill.load"; + +// Backing field indices (0 is the vtable). `Skill` extends `SkillInfo`'s layout. +const S_NAME: usize = 1; +const S_DESCRIPTION: usize = 2; +const S_CONTENT: usize = 3; + +pub fn install(linker: &mut Linker) -> wasmtime::Result<()> { + let engine = linker.engine().clone(); + let intr = build_intrinsic_types(&engine)?; + let string = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.string.clone()), + )); + let nullable_object = ValType::Ref(RefType::new( + true, + HeapType::ConcreteStruct(intr.object.clone()), + )); + let object = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.object.clone()), + )); + let array = ValType::Ref(RefType::new( + false, + HeapType::ConcreteStruct(intr.array.clone()), + )); + + register_host_fn_async( + linker, + MODULE_NAME, + crate::mangle::package_symbol(MODULE_NAME, "list"), + FuncType::new(&engine, [], [array]), + /* deterministic = */ false, + |caller, _params, results| { + Box::pin(async move { + *abi_result(results, 0)? = list(caller).await?; + Ok(()) + }) + }, + )?; + + register_host_fn_async( + linker, + MODULE_NAME, + crate::mangle::package_symbol(MODULE_NAME, "load"), + // A `Skill` crosses as the universal `(ref null $Object)` lowering. + FuncType::new(&engine, [string.clone()], [nullable_object.clone()]), + /* deterministic = */ false, + |caller, params, results| { + Box::pin(async move { + let name = + read_string_arg(&mut *caller, abi_arg(params, 0)?, "skills.load (name)")?; + *abi_result(results, 0)? = load(caller, name).await?; + Ok(()) + }) + }, + )?; + + register_host_fn_async( + linker, + MODULE_NAME, + crate::mangle::package_symbol(MODULE_NAME, "readFile"), + FuncType::new(&engine, [string.clone(), string.clone()], [string.clone()]), + /* deterministic = */ false, + |caller, params, results| { + Box::pin(async move { + let name = + read_string_arg(&mut *caller, abi_arg(params, 0)?, "skills.readFile (name)")?; + let path = + read_string_arg(&mut *caller, abi_arg(params, 1)?, "skills.readFile (path)")?; + *abi_result(results, 0)? = read_file(caller, name, path).await?; + Ok(()) + }) + }, + )?; + + for iface in ["SkillInfo", "Skill"] { + let mut rows = vec![ + ("name", S_NAME, string.clone()), + ("description", S_DESCRIPTION, nullable_object.clone()), + ]; + if iface == "Skill" { + rows.push(("content", S_CONTENT, string.clone())); + } + install_field_getters(linker, MODULE_NAME, iface, &engine, &object, &rows)?; + } + Ok(()) +} + +/// The capability check, run before anything reaches the harness. +fn gate( + caller: &mut wasmtime::Caller<'_, StoreData>, + name: &str, +) -> wasmtime::Result> { + check_security_call(caller, CAPABILITY, serde_json::json!({ "name": name })) +} + +/// `list()`: every skill the harness offers that the caller may load. A denied +/// candidate is left out, never reported. +async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result { + preflight_listing(caller, CAPABILITY, &serde_json::json!({ "name": "" }))?; + let provider = provider(caller, "list")?; + let candidates = provider.list().await.map_err(|e| throw("list", &e))?; + let mut visible = Vec::new(); + for candidate in candidates { + let keeps = filters_candidate(gate(caller, &candidate.name).map(|_| ()))?; + if keeps { + visible.push(candidate); + } else { + mark_filtered(&*caller); + } + } + let mut built = Vec::with_capacity(visible.len()); + for skill in visible { + built.push(build_skill_info(caller, skill)?); + } + abi::new_array(caller, &built) +} + +async fn load(caller: &mut wasmtime::Caller<'_, StoreData>, name: String) -> wasmtime::Result { + let ticket = gate(caller, &name)?; + record_payload(&*caller, ticket, Side::Request, || { + Payload::meta(serde_json::json!({ "op": "load", "name": name })) + }); + let provider = provider(caller, "load")?; + match provider.load(&name).await { + Ok(skill) => { + record_text(caller, ticket, &skill.content); + fuel::settle(&mut *caller, fuel::IO, skill.content.len() as u64)?; + fuel::settle_result(caller, |caller| build_skill(caller, skill)) + } + Err(error) => Err(fail(caller, ticket, "load", &error)), + } +} + +async fn read_file( + caller: &mut wasmtime::Caller<'_, StoreData>, + name: String, + path: String, +) -> wasmtime::Result { + let ticket = gate(caller, &name)?; + record_payload(&*caller, ticket, Side::Request, || { + Payload::meta(serde_json::json!({ "op": "readFile", "name": name, "path": path })) + }); + if !is_skill_path(&path) { + return Err(fail( + caller, + ticket, + "readFile", + &SkillError::InvalidPath { path }, + )); + } + let provider = provider(caller, "readFile")?; + match provider.read_file(&name, &path).await { + Ok(text) => { + record_text(caller, ticket, &text); + fuel::settle(&mut *caller, fuel::IO, text.len() as u64)?; + fuel::settle_result(caller, |caller| { + let text = write_submilli_string_struct(caller, &text)?; + Ok(Val::AnyRef(Some(text.to_anyref()))) + }) + } + Err(error) => Err(fail(caller, ticket, "readFile", &error)), + } +} + +/// A path inside a skill: relative, `/`-separated, with no empty, `.` or `..` +/// segment, and no backslash or NUL a provider could read as structure. +fn is_skill_path(path: &str) -> bool { + !path.contains(['\\', '\0']) + && path + .split('/') + .all(|segment| !matches!(segment, "" | "." | "..")) +} + +fn record_text(caller: &wasmtime::Caller<'_, StoreData>, ticket: Option, text: &str) { + record_payload(caller, ticket, Side::Response, || { + Payload::meta(serde_json::Value::Null) + .with_owned_body(text.as_bytes().to_vec()) + .with_size(text.len() as u64) + }); +} + +/// Record `error` as the call's response and turn it into the guest's error. +fn fail( + caller: &wasmtime::Caller<'_, StoreData>, + ticket: Option, + op: &str, + error: &SkillError, +) -> wasmtime::Error { + record_payload(caller, ticket, Side::Response, || { + Payload::meta(serde_json::json!({ "call_error": error_record(error) })) + }); + throw(op, error) +} + +/// Clone the provider out of the store before any `await`. Runs after the +/// capability check, so a denied caller cannot learn whether a harness is wired. +fn provider( + caller: &wasmtime::Caller<'_, StoreData>, + op: &str, +) -> wasmtime::Result> { + caller + .data() + .skill_provider + .clone() + .ok_or_else(|| throw(op, &SkillError::NotConfigured)) +} + +/// A path outside the skill is an argument the program got wrong; every other +/// failure keeps the base error type. +fn throw(op: &str, error: &SkillError) -> wasmtime::Error { + let message = format!("skills.{op}: {error}"); + if matches!(error, SkillError::InvalidPath { .. }) { + range_error(message) + } else { + wasmtime::Error::msg(message) + } +} + +fn error_record(error: &SkillError) -> serde_json::Value { + match error { + SkillError::NotConfigured => serde_json::json!({ "kind": "not-configured" }), + SkillError::NotFound { name } => serde_json::json!({ "kind": "not-found", "name": name }), + SkillError::FileNotFound { name, path } => { + serde_json::json!({ "kind": "file-not-found", "name": name, "path": path }) + } + SkillError::InvalidPath { path } => { + serde_json::json!({ "kind": "invalid-path", "path": path }) + } + SkillError::Failed { message } => { + serde_json::json!({ "kind": "failed", "message": message }) + } + } +} + +fn info_backing_struct(engine: &wasmtime::Engine) -> wasmtime::Result { + let intr = build_intrinsic_types(engine)?; + backing_struct( + engine, + &intr, + vec![string_field(&intr), nullable_object_field(&intr)], + ) +} + +fn skill_backing_struct(engine: &wasmtime::Engine) -> wasmtime::Result { + let intr = build_intrinsic_types(engine)?; + backing_struct( + engine, + &intr, + vec![ + string_field(&intr), + nullable_object_field(&intr), + string_field(&intr), + ], + ) +} + +fn build_skill_info( + caller: &mut wasmtime::Caller<'_, StoreData>, + skill: SkillInfo, +) -> wasmtime::Result { + let name = write_submilli_string_struct(caller, &skill.name)?; + let description = description(caller, skill.description.as_deref(), true)?; + let ty = info_backing_struct(caller.engine())?; + abi::new_backing( + caller, + ty, + &[Val::AnyRef(Some(name.to_anyref())), description], + ) +} + +fn build_skill( + caller: &mut wasmtime::Caller<'_, StoreData>, + skill: Skill, +) -> wasmtime::Result { + let name = write_submilli_string_struct(caller, &skill.name)?; + let description = description(caller, skill.description.as_deref(), false)?; + let content = write_submilli_string_struct(caller, &skill.content)?; + let ty = skill_backing_struct(caller.engine())?; + abi::new_backing( + caller, + ty, + &[ + Val::AnyRef(Some(name.to_anyref())), + description, + Val::AnyRef(Some(content.to_anyref())), + ], + ) +} + +/// A listing shows a description as one bounded line, because it steers which +/// skill a program picks; a loaded skill's description is part of what the +/// program asked to read. +fn description( + caller: &mut wasmtime::Caller<'_, StoreData>, + text: Option<&str>, + in_listing: bool, +) -> wasmtime::Result { + let text = if in_listing { + text.and_then(sanitize_description) + } else { + text.map(str::to_string) + }; + match text { + Some(text) => Ok(Val::AnyRef(Some( + write_submilli_string_struct(caller, &text)?.to_anyref(), + ))), + None => crate::runtime::prelude::undefined::value(caller), + } +} + +#[cfg(test)] +mod path_tests { + use super::is_skill_path; + + #[test] + fn only_relative_paths_inside_the_skill_are_accepted() { + for ok in ["SKILL.md", "templates/report.md", "a/b/c.txt", ".hidden"] { + assert!(is_skill_path(ok), "{ok}"); + } + for bad in [ + "", + "/etc/passwd", + "a//b", + "./a", + "a/.", + "../x", + "a/../b", + "a/", + "a\\b", + "a\0b", + ] { + assert!(!is_skill_path(bad), "{bad:?}"); + } + } +} diff --git a/crates/interpreter/src/typechecker/infer/expr.rs b/crates/interpreter/src/typechecker/infer/expr.rs index 2ebd345b0..c5cb5d50b 100644 --- a/crates/interpreter/src/typechecker/infer/expr.rs +++ b/crates/interpreter/src/typechecker/infer/expr.rs @@ -3529,16 +3529,26 @@ impl Inferer<'_> { /// means a diagnostic was reported (or deliberately suppressed) and the /// call is an error. /// - /// Call only for a [`crate::stdlib::llm::declaration::is_checked_call`] - /// mangled name. `type_args_written` separates an explicit `call` - /// from a bare `call(...)`, whose result is the `Completion` envelope and - /// needs no check. + /// `checked` describes the call, from [`crate::stdlib::schema_checked_call`]. + /// `type_args_written` separates an explicit `call` from a bare + /// `call(...)`, whose result is the untyped default and needs no check. pub(super) fn llm_call_schema( &mut self, + checked: &crate::stdlib::SchemaCheckedCall, result_ty: &Type, type_args_written: bool, span: Span, ) -> Result, ()> { + let crate::stdlib::SchemaCheckedCall { + callee, + example, + checks, + answerer, + untyped_read, + untyped_unknown, + untyped_parse, + .. + } = checked; // No type argument: the call keeps its pre-generic meaning and returns // the `Completion` envelope, which the declaration already typed. There // is nothing to check and no schema to send. @@ -3552,16 +3562,15 @@ impl Inferer<'_> { if matches!(result_ty.peel(), Type::Unknown) { self.error_with_help( span, - "`llm.call` would not verify anything: `unknown` admits every \ - value, so no runtime check is possible and its JSON Schema could only \ - be `{}`, which constrains the model to nothing" - .to_string(), - vec![ - "name the shape you expect — `llm.call(model, prompt)` — \ - or drop the type argument and read the `Completion` envelope's \ - `ok` and `text` yourself." - .to_string(), - ], + format!( + "`{callee}` would not verify anything: `unknown` admits every \ + value, so no runtime check is possible and its JSON Schema could only \ + be `{{}}`, which constrains {answerer} to nothing" + ), + vec![format!( + "name the shape you expect — `{example}` — or drop the type argument \ + and {untyped_unknown}." + )], ); return Err(()); } @@ -3580,14 +3589,13 @@ impl Inferer<'_> { { self.error_with_help( span, - format!("`llm.call<{result_ty}>` cannot be verified at runtime: {reason}"), + format!("`{callee}<{result_ty}>` cannot be verified at runtime: {reason}"), vec![format!( - "`llm.call` checks the model's response against its type argument, so \ + "`{callee}` checks {checks} against its type argument, so \ that argument must be one the runtime can test, and the schema is \ emitted at compile time where `{result_ty}` is not yet known. Call it \ - at a concrete type — `llm.call(model, prompt)` — inside the \ - generic function, or drop the type argument and read the `Completion` \ - envelope yourself." + at a concrete type — `{example}` — inside the \ + generic function, or drop the type argument and {untyped_read}." )], ); return Err(()); @@ -3607,14 +3615,14 @@ impl Inferer<'_> { { self.error_with_help( span, - format!("`llm.call<{result_ty}>` cannot be verified at runtime: {reason}"), + format!("`{callee}<{result_ty}>` cannot be verified at runtime: {reason}"), vec![format!( - "`llm.call` checks the model's response against its type \ + "`{callee}` checks {checks} against its type \ argument, so that argument must be one the runtime can test: \ an object, array, tuple, union, or primitive shape. Call it \ at a concrete type instead of `{result_ty}` — \ - `llm.call(model, prompt)` — or drop the type \ - argument and read the `Completion` envelope yourself." + `{example}` — or drop the type \ + argument and {untyped_read}." )], ); return Err(()); @@ -3628,18 +3636,16 @@ impl Inferer<'_> { self.error_with_help( span, format!( - "`llm.call<{result_ty}>` has no JSON Schema: {}", + "`{callee}<{result_ty}>` has no JSON Schema: {}", reject.describe() ), - vec![ - "the schema sent to the model is fully inlined and carries no \ + vec![format!( + "the schema sent to {answerer} is fully inlined and carries no \ `$ref`, so every field must be an object, array, tuple, union, \ enum, or primitive shape. Replace that field with one — a \ `string` for bytes or a big number, a named shape in place of \ - `unknown` — or drop the type argument and parse the \ - `Completion` text yourself." - .to_string(), - ], + `unknown` — or drop the type argument and {untyped_parse}." + )], ); } Err(()) @@ -3663,7 +3669,7 @@ impl Inferer<'_> { Ok(checked) => checked, Err(reason) => { return Err(super::inference_failure(&format!( - "LLM result cast rejected a previously validated schema: {reason}" + "schema-checked result cast rejected a previously validated schema: {reason}" )) .with_span(span)); } diff --git a/crates/interpreter/src/typechecker/infer/generic.rs b/crates/interpreter/src/typechecker/infer/generic.rs index 01d2f4809..2565dec49 100644 --- a/crates/interpreter/src/typechecker/infer/generic.rs +++ b/crates/interpreter/src/typechecker/infer/generic.rs @@ -2256,7 +2256,7 @@ impl Inferer<'_> { // reason. They differ from `session.get` only in what a bare call means // — the `Completion` envelope rather than an unchecked `unknown` — and // in carrying a compile-time schema into the trailing argument. - let checked_llm = crate::stdlib::llm::declaration::is_checked_call(&mangled); + let checked_llm = crate::stdlib::schema_checked_call(&mangled); if let Some(targs) = &type_args { if targs.len() != generics.len() { @@ -2371,11 +2371,13 @@ impl Inferer<'_> { // is not an unchecked read, it is a different fully-typed result. `T` // appears only in the return type, so it is never inferable from an // argument and would otherwise always trip the unbound-parameter error. - if checked_llm && !type_args_written { + if let Some(checked) = &checked_llm + && !type_args_written + { bind_remaining( &mut sub, &generics, - crate::stdlib::llm::declaration::untyped_result_type(&mangled), + checked.untyped_result.clone(), &self.type_limits, ) .map_err(type_limit_at(span))?; @@ -2431,16 +2433,20 @@ impl Inferer<'_> { // unaffected in behavior — `substitute_schema_argument` overwrites the // slot — but a written argument there is equally meaningless, so both // forms are refused and no working program changes. - if checked_llm && args.len() > 2 { + if let Some(checked) = &checked_llm + && args.len() > checked.written_count + { let name = &callee_ident.name; + let written = checked.written; + let extra = checked.extra_argument; self.error_with_help( span, format!( - "`{name}` takes the model and the prompt; the schema argument is filled by \ + "`{name}` takes {written}; the schema argument is filled by \ the compiler from the type argument" ), vec![format!( - "drop the third argument — write `{name}(...)` to send a schema for `T`, \ + "drop the {extra} argument — write `{name}(...)` to send a schema for `T`, \ or `{name}(...)` for an untyped call" )], ); @@ -2448,8 +2454,8 @@ impl Inferer<'_> { } let mut llm_schema = None; - if checked_llm { - match self.llm_call_schema(&result_ty, type_args_written, span) { + if let Some(checked) = &checked_llm { + match self.llm_call_schema(checked, &result_ty, type_args_written, span) { Ok(schema) => llm_schema = schema, Err(()) => return Ok((TypedExprKind::Null, Type::Error)), } @@ -2497,7 +2503,7 @@ impl Inferer<'_> { mangled, type_args: runtime_args, args: generic_args, - return_cast: if checked_get || checked_llm { + return_cast: if checked_get || checked_llm.is_some() { None } else { return_cast @@ -2509,7 +2515,7 @@ impl Inferer<'_> { } // An untyped `llm.call` emitted no schema and needs no check: it returns // the `Completion` envelope the declaration already typed. - if checked_llm && llm_schema.is_some() { + if checked_llm.is_some() && llm_schema.is_some() { return self.checked_llm_cast(call, &result_ty, span); } Ok((call, result_ty)) diff --git a/docs/part-6-reference/standard-library.md b/docs/part-6-reference/standard-library.md index b1a7b61e6..07a52d42f 100644 --- a/docs/part-6-reference/standard-library.md +++ b/docs/part-6-reference/standard-library.md @@ -7,7 +7,7 @@ sidebar: authorship: label: ai-assisted confirmed: true - contentHash: "8b2e285130d62bdc705ab4f93500a9b8576133777739e04cec5e209f79462dd3" + contentHash: "3793fac8286c446ca61433ddc6b5f69445e64bf9b2ec0d36fb2c3e98b517179e" confirmedAt: "2026-10-09T15:40:52.000Z" --- @@ -199,6 +199,32 @@ whether the Package's caller may perform `capability` with the fields in `expectException(fn, errorType?)` checks that `fn` throws ([Write tests](/docs/packages/write-tests)). +## Modules a harness provides + +Two modules exist only where the harness running the program provides them. +The `submilli` CLI and server provide neither: importing one there fails with +``package `submilli:agents` is not available in this harness``, and neither is +listed by `submilli search` or in the sections below. + +| Module | What it does | Gated by | +| --- | --- | --- | +| `submilli:agents` | Sub-agents: `run(agent, input)`, `list()` | `agent.run`, on the field `agent` | +| `submilli:skills` | Skills: `list()`, `load(name)`, `readFile(name, path)` | `skill.load`, on the field `name` | + +- `run(agent, input)` returns the agent's final answer as text. With a type + argument it works like `llm.call`: the schema for `T` is sent with the + task, and an answer that is not JSON or does not match `T` throws + `TypeError`. +- The harness decides how long a run may take and what it may spend. The + execution timeout does not stop a run in progress. +- `list()` in either module leaves out what the policy denies the caller, + without saying how many were left out. +- `readFile(name, path)` takes a path relative to the skill, with `/` + separators. An absolute path, or one with an empty, `.`, or `..` segment, + throws `RangeError`. Reading a file is gated by `skill.load` on the skill's + name. +- With no provider configured, every function throws an `Error` saying so. + ## `submilli:code` diff --git a/plans/sub-1269-host-fuel-costs.md b/plans/sub-1269-host-fuel-costs.md index de268febc..e4215e4fb 100644 --- a/plans/sub-1269-host-fuel-costs.md +++ b/plans/sub-1269-host-fuel-costs.md @@ -1816,6 +1816,32 @@ The result holds its vectors as little-endian `f32` bytes in a hidden packed-`i8 | `submilli:embedding#Embeddings#bytes` | Copy one row out of the hidden array into a new `Uint8Array` (`read_row`, `write_submilli_uint8array_struct`) | `CALL + COPY(d x 4) + COPY(d x 4)` | before | One `COPY` for the read out of the result and one for the new array, charged by `write_uint8_array`. | | `submilli:embedding#Embeddings#count`, `#dimensions`, `#identity`, `#model`, `#inputTokens`; `EmbeddingModel` fields | Field read | `CALL` | before | Through `install_field_getters`. | +### submilli:agents + +Optional: installed only for an embedder that enables it. Variables: `I` = input bytes; `S` = schema bytes; `T` = bytes of the agent's answer; `m` = agents offered. + +| Function | What the host does | Formula | Charge point | Notes | +|---|---|---|---|---| +| `submilli:agents#run` | Read the agent, input and schema, gate, one provider run, then build a string or, typed, parse the answer and allocate the value tree (`stdlib/agents/mod.rs` `run`) | `CALL + GATE + IO(I + S) + IO(T)`; untyped adds the answer string through `write_submilli_string_struct`, typed adds `PARSE(T) + ELEM(nodes)` | `IO(I + S)` before `provider.run(...).await`; `IO(T)` and the result after it | The run is the effect, so everything after it uses `settle` or `settle_result` and never refuses. Waiting on the run costs nothing; the provider bounds its time and tokens. | +| `submilli:agents#list` | Gate, list the agents, run the policy check once per agent, sanitize each description, build `AgentInfo` structs and an array (`stdlib/agents/mod.rs` `list`) | `CALL + (1 + m) x GATE + ELEM(m)` plus the strings through `write_submilli_string_struct` | before + output | `m` is known after `provider.agents().await`. | +| `submilli:agents#AgentInfo#description` | Field read | `CALL` | before | | +| `submilli:agents#AgentInfo#name` | Field read | `CALL` | before | | + +### submilli:skills + +Optional: installed only for an embedder that enables it. Variables: `T` = bytes of the skill's content or the file read; `m` = skills offered. + +| Function | What the host does | Formula | Charge point | Notes | +|---|---|---|---|---| +| `submilli:skills#list` | Gate, list the skills, run the policy check once per skill, sanitize each description, build `SkillInfo` structs and an array (`stdlib/skills/mod.rs` `list`) | `CALL + (1 + m) x GATE + ELEM(m)` plus the strings through `write_submilli_string_struct` | before + output | `m` is known after `provider.list().await`. | +| `submilli:skills#load` | Gate, one provider read, build the `Skill` struct (`stdlib/skills/mod.rs` `load`) | `CALL + GATE + IO(T)` plus the strings through `write_submilli_string_struct` | `IO(T)` and the result after the read | The read is the effect, so the result is built under `settle_result`. | +| `submilli:skills#readFile` | Gate, check the path, one provider read, build the string (`stdlib/skills/mod.rs` `read_file`) | `CALL + GATE + IO(T)` plus the string through `write_submilli_string_struct` | `IO(T)` and the result after the read | A path outside the skill is refused before the provider is asked. | +| `submilli:skills#Skill#content` | Field read | `CALL` | before | | +| `submilli:skills#Skill#description` | Field read | `CALL` | before | | +| `submilli:skills#Skill#name` | Field read | `CALL` | before | | +| `submilli:skills#SkillInfo#description` | Field read | `CALL` | before | | +| `submilli:skills#SkillInfo#name` | Field read | `CALL` | before | | + ### submilli:mcp | Function | What the host does | Formula | Charge point | Notes | From c79630d414e08cdcf58ee0f24424d7fd0d7c1b93 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 17:50:02 +0300 Subject: [PATCH 04/10] Extract the policy engine into submilli-policy The permission rules, the filter language, session variables and auth-proxy injection move out of submilli-blueprint into a format-neutral crate, so an embedder that keeps policy outside a blueprint file evaluates it the same way. Auth-proxy secrets resolve by name through SecretResolver; the blueprint ties names to its secrets: block through DeclaredSecrets and the source-keyed SourceSecretResolver. Behind the engine feature, submilli_policy::host holds the adapters an embedder installs on a store: PolicyCheck over a Policy, PolicyAuthProxy and PolicySecretProvider. submilli-shared keeps the blueprint wiring on top of them. submilli-blueprint keeps the YAML format, its validation with YAML paths, and the diff and draft tooling, and re-exports the policy types under their existing names. A test in submilli-policy keeps the engine's filter-literal quoting in step with the policy parser's. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 5 +- Cargo.lock | 16 + Cargo.toml | 1 + crates/submilli-blueprint/Cargo.toml | 1 + crates/submilli-blueprint/src/auth_proxy.rs | 246 ++------ crates/submilli-blueprint/src/edit.rs | 9 +- crates/submilli-blueprint/src/endpoint.rs | 2 +- crates/submilli-blueprint/src/lib.rs | 123 +--- crates/submilli-blueprint/src/maps.rs | 40 +- crates/submilli-blueprint/src/mcp.rs | 2 +- crates/submilli-blueprint/src/permissions.rs | 476 +-------------- crates/submilli-blueprint/src/variables.rs | 85 +-- crates/submilli-policy/Cargo.toml | 30 + crates/submilli-policy/src/auth_proxy.rs | 271 +++++++++ .../src/filter.rs | 21 +- crates/submilli-policy/src/host.rs | 468 +++++++++++++++ crates/submilli-policy/src/lib.rs | 36 ++ crates/submilli-policy/src/permissions.rs | 553 ++++++++++++++++++ crates/submilli-policy/src/serde_support.rs | 124 ++++ crates/submilli-policy/src/variables.rs | 86 +++ .../tests/engine_literal_parity.rs | 68 +++ .../submilli-server/src/handlers/execute.rs | 2 +- crates/submilli-server/src/mcp/server.rs | 6 +- .../tests/decision_records_policy.rs | 2 +- crates/submilli-server/tests/replay.rs | 2 +- crates/submilli-shared/Cargo.toml | 1 + crates/submilli-shared/src/host.rs | 454 +++----------- crates/submilli/src/commands/run.rs | 5 +- 28 files changed, 1853 insertions(+), 1282 deletions(-) create mode 100644 crates/submilli-policy/Cargo.toml create mode 100644 crates/submilli-policy/src/auth_proxy.rs rename crates/{submilli-blueprint => submilli-policy}/src/filter.rs (99%) create mode 100644 crates/submilli-policy/src/host.rs create mode 100644 crates/submilli-policy/src/lib.rs create mode 100644 crates/submilli-policy/src/permissions.rs create mode 100644 crates/submilli-policy/src/serde_support.rs create mode 100644 crates/submilli-policy/src/variables.rs create mode 100644 crates/submilli-policy/tests/engine_literal_parity.rs diff --git a/AGENTS.md b/AGENTS.md index 96243b8f1..2dfdfe5b2 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -43,8 +43,9 @@ These rules govern `crates/submilli-server/src/domain/` and not make them domain concepts. Existing exceptions are not precedents. - **Domain is pure.** It owns business rules and state transitions, with no I/O, clock reads, or dependencies on server modules outside `domain`. It may depend - on the shared kernel, currently `submilli-blueprint`. Reuse its `Blueprint` - type rather than introducing a wrapper solely for storage concerns. + on the shared kernel, currently `submilli-blueprint` and the `submilli-policy` + types it is built on. Reuse its `Blueprint` type rather than introducing a + wrapper solely for storage concerns. - Aggregates protect their invariants through meaningful operations such as `close`, `expire`, `recover`, and `replace_credentials`. Application code calls those operations rather than changing fields directly. Names must describe diff --git a/Cargo.lock b/Cargo.lock index 718063490..59799ab61 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5473,6 +5473,7 @@ dependencies = [ "serde_json", "serde_path_to_error", "serde_yml", + "submilli-policy", "tokio", "url", ] @@ -5490,6 +5491,20 @@ dependencies = [ "toml", ] +[[package]] +name = "submilli-policy" +version = "0.3.0" +dependencies = [ + "async-trait", + "base64 0.22.1", + "interpreter", + "regex", + "serde", + "serde_json", + "tokio", + "url", +] + [[package]] name = "submilli-server" version = "0.3.0" @@ -5561,6 +5576,7 @@ dependencies = [ "sse-stream", "submilli-blueprint", "submilli-build", + "submilli-policy", "tar", "tempfile", "tokio", diff --git a/Cargo.toml b/Cargo.toml index 49f501b24..591eb95a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,6 +6,7 @@ members = [ "crates/submilli", "crates/submilli-build", "crates/submilli-blueprint", + "crates/submilli-policy", "crates/submilli-shared", "crates/submilli-server", ] diff --git a/crates/submilli-blueprint/Cargo.toml b/crates/submilli-blueprint/Cargo.toml index 8ae3b3e84..8344d2afb 100644 --- a/crates/submilli-blueprint/Cargo.toml +++ b/crates/submilli-blueprint/Cargo.toml @@ -13,6 +13,7 @@ workspace = true path = "src/lib.rs" [dependencies] +submilli-policy = { path = "../submilli-policy" } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } serde_path_to_error = { workspace = true } diff --git a/crates/submilli-blueprint/src/auth_proxy.rs b/crates/submilli-blueprint/src/auth_proxy.rs index 6fb9637c5..94bbd14fd 100644 --- a/crates/submilli-blueprint/src/auth_proxy.rs +++ b/crates/submilli-blueprint/src/auth_proxy.rs @@ -1,224 +1,70 @@ -//! The blueprint `auth_proxy:` block — host-keyed rules that inject auth -//! headers / query params into outbound HTTP, with `${secrets.X}` resolved from -//! the `secrets:` block. The script never sees the resolved values. -//! -//! This module is interpreter-free: it parses + validates the rules and, given -//! a [`SecretResolver`], computes what to inject. The embedder (`submilli-server`) -//! supplies the resolver and adapts the result to the runtime's `AuthProxy` trait. +//! The blueprint `auth_proxy:` block. The rules and their resolution live in +//! `submilli-policy`; this ties them to the blueprint's `secrets:` block — +//! a `${secrets.X}` must name a declared secret, resolved from where the +//! declaration says — and validates the rules with the YAML path of the +//! offending key. -use std::collections::BTreeMap; -use std::fmt; - -use base64::{Engine as _, engine::general_purpose::STANDARD}; -use serde::{Deserialize, Serialize}; +use submilli_policy::{AuthError, AuthSpec, Injections, SecretResolver, secret_refs}; use crate::{Blueprint, BlueprintError, Fault, SecretSource, yaml_path}; -const PLACEHOLDER_PREFIX: &str = "${secrets."; - -/// One host-keyed injection rule. v1 matches `host` exactly. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct AuthProxyRule { - pub host: String, - /// Also requires the blueprint-wide opt-in to permit cleartext requests. - #[serde(default, skip_serializing_if = "std::ops::Not::not")] - pub allow_insecure_http: bool, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub auth: Option, - #[serde( - default, - skip_serializing_if = "BTreeMap::is_empty", - deserialize_with = "crate::maps::deserialize" - )] - pub headers: BTreeMap, - #[serde( - default, - skip_serializing_if = "BTreeMap::is_empty", - deserialize_with = "crate::maps::deserialize" - )] - pub query: BTreeMap, -} - -/// A first-class auth method, lowered into an `Authorization` header at resolve -/// time. Exactly one of `bearer`/`basic` is set (enforced by validation). -/// `bearer` / basic `password` name declared secrets; basic `username` is a -/// literal. Basic auth can't be expressed as an interpolation-only header value — -/// its `base64(user:pass)` is computed *after* the password secret resolves. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct AuthSpec { - #[serde(default, skip_serializing_if = "Option::is_none")] - pub bearer: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub basic: Option, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct BasicAuth { - pub username: String, - pub password: String, -} - -/// Resolves a declared secret to its value. Implemented by the embedder -/// (store or harness). Async so a `store:` source can `await` the +/// Resolves a declared secret from its declaration's source. Implemented by the +/// embedder (store or harness). Async so a `store:` source can `await` the /// `SecretStore` without blocking the executor. #[async_trait::async_trait] -pub trait SecretResolver: Sync { +pub trait SourceSecretResolver: Sync { async fn resolve(&self, name: &str, source: &SecretSource) -> Result; } -/// What an auth-proxy rule contributes to a request. Header/query *names* are -/// taken verbatim; values have their `${secrets.X}` placeholders resolved. -#[derive(Debug, Clone, PartialEq, Eq, Default)] -pub struct Injections { - pub headers: Vec<(String, String)>, - pub query: Vec<(String, String)>, +/// A blueprint's declared secrets as a policy [`SecretResolver`]: a name the +/// `secrets:` block does not declare is [`AuthError::UndeclaredSecret`], and a +/// declared one resolves from its source through `inner`. +pub struct DeclaredSecrets<'a> { + pub blueprint: &'a Blueprint, + pub inner: &'a dyn SourceSecretResolver, } -/// Runtime auth-proxy failure. Maps onto the runtime's `AuthProxyError`. -#[derive(Debug)] -pub enum AuthError { - /// `${secrets.X}` referenced a name not in the `secrets:` block. (Caught at - /// parse time too; this guards a resolver fed a stale blueprint.) - UndeclaredSecret(String), - /// Secret declared but its source produced no value. - MissingSecret(String), - Other(String), -} - -impl fmt::Display for AuthError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - AuthError::UndeclaredSecret(name) => write!(f, "undeclared secret '{name}'"), - AuthError::MissingSecret(name) => write!(f, "missing secret '{name}'"), - AuthError::Other(msg) => f.write_str(msg), - } - } -} - -impl std::error::Error for AuthError {} - -/// The `${secrets.NAME}` names referenced by a value, in order. -pub fn secret_refs(value: &str) -> Vec<&str> { - let mut names = Vec::new(); - let mut rest = value; - while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { - let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; - match after.find('}') { - Some(end) => { - names.push(&after[..end]); - rest = &after[end + 1..]; - } - None => break, - } +#[async_trait::async_trait] +impl SecretResolver for DeclaredSecrets<'_> { + async fn resolve(&self, name: &str) -> Result { + let source = self + .blueprint + .secrets + .get(name) + .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; + self.inner.resolve(name, source).await } - names } -/// The first rule whose `host` matches exactly, with `${secrets.X}` resolved. -/// `Ok(None)` when no rule matches. +/// The first `auth_proxy` rule whose `host` matches exactly, with +/// `${secrets.X}` resolved against the declared secrets. `Ok(None)` when no +/// rule matches. pub async fn resolve_injections( blueprint: &Blueprint, host: &str, - resolver: &dyn SecretResolver, + resolver: &dyn SourceSecretResolver, ) -> Result, AuthError> { - let Some(rule) = blueprint.auth_proxy.iter().find(|r| r.host == host) else { - return Ok(None); + let secrets = DeclaredSecrets { + blueprint, + inner: resolver, }; - let mut headers = interpolate_pairs(&rule.headers, blueprint, resolver).await?; - if let Some(auth) = &rule.auth { - headers.push(( - "Authorization".to_string(), - resolve_authorization(auth, blueprint, resolver).await?, - )); - } - Ok(Some(Injections { - headers, - query: interpolate_pairs(&rule.query, blueprint, resolver).await?, - })) -} - -/// The `Authorization` header value for an `auth:` method: `Bearer ` or -/// `Basic `. `bearer`/`password` name declared secrets and -/// are resolved directly (not `${secrets.X}` interpolation). -async fn resolve_authorization( - auth: &AuthSpec, - blueprint: &Blueprint, - resolver: &dyn SecretResolver, -) -> Result { - if let Some(secret) = &auth.bearer { - return Ok(format!( - "Bearer {}", - resolve_secret(secret, blueprint, resolver).await? - )); - } - if let Some(basic) = &auth.basic { - let password = resolve_secret(&basic.password, blueprint, resolver).await?; - let token = STANDARD.encode(format!("{}:{password}", basic.username)); - return Ok(format!("Basic {token}")); - } - // Unreachable after validation, which requires exactly one method. - Err(AuthError::Other( - "auth_proxy rule has an empty `auth:` block".into(), - )) -} - -/// Resolve a declared secret by name (as opposed to `${secrets.X}` placeholders -/// inside a value string). -async fn resolve_secret( - name: &str, - blueprint: &Blueprint, - resolver: &dyn SecretResolver, -) -> Result { - let source = blueprint - .secrets - .get(name) - .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; - resolver.resolve(name, source).await + submilli_policy::resolve_injections(&blueprint.auth_proxy, host, &secrets).await } -async fn interpolate_pairs( - pairs: &BTreeMap, - blueprint: &Blueprint, - resolver: &dyn SecretResolver, -) -> Result, AuthError> { - let mut out = Vec::with_capacity(pairs.len()); - for (name, value) in pairs { - out.push((name.clone(), interpolate(value, blueprint, resolver).await?)); - } - Ok(out) -} - -/// Replace every `${secrets.NAME}` in `value` with its resolved secret. Public so -/// other blueprint blocks that interpolate secrets (e.g. the `mcp:` OAuth -/// `client_id`) can reuse the exact placeholder semantics `auth_proxy` uses. +/// Replace every `${secrets.NAME}` in `value` with its resolved declared +/// secret. Public so other blueprint blocks that interpolate secrets (e.g. the +/// `mcp:` OAuth `client_id`) reuse the exact placeholder semantics `auth_proxy` +/// uses. pub async fn interpolate( value: &str, blueprint: &Blueprint, - resolver: &dyn SecretResolver, + resolver: &dyn SourceSecretResolver, ) -> Result { - let mut out = String::new(); - let mut rest = value; - while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { - out.push_str(&rest[..start]); - let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; - let end = after.find('}').ok_or_else(|| { - AuthError::Other(format!( - "unterminated '{PLACEHOLDER_PREFIX}...}}' in '{value}'" - )) - })?; - let name = &after[..end]; - let source = blueprint - .secrets - .get(name) - .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; - out.push_str(&resolver.resolve(name, source).await?); - rest = &after[end + 1..]; - } - out.push_str(rest); - Ok(out) + let secrets = DeclaredSecrets { + blueprint, + inner: resolver, + }; + submilli_policy::interpolate(value, &secrets).await } /// Resolve **every declared secret**, to verify (at blueprint apply/add time) @@ -226,10 +72,10 @@ pub async fn interpolate( /// `auth_proxy:` — the `secrets:` block is the operator's declaration of what /// exists in this sandbox, so all of it is checked (whether or not auth_proxy /// references it). Point-in-time only: a later deletion from the store is the -/// runtime's concern, not a reason to reject the registration. IO lives in the embedder's [`SecretResolver`]. +/// runtime's concern, not a reason to reject the registration. IO lives in the embedder's [`SourceSecretResolver`]. pub async fn verify_secrets( blueprint: &Blueprint, - resolver: &dyn SecretResolver, + resolver: &dyn SourceSecretResolver, ) -> Result<(), AuthError> { for (name, source) in &blueprint.secrets { // Harness secrets are bound when a session opens — there is nothing to @@ -329,6 +175,8 @@ fn auth_secret_refs(auth: &AuthSpec) -> Vec<&str> { #[cfg(test)] mod tests { + use base64::{Engine as _, engine::general_purpose::STANDARD}; + use super::*; use crate::parse; @@ -337,7 +185,7 @@ mod tests { missing: Option<&'static str>, } #[async_trait::async_trait] - impl SecretResolver for StubResolver { + impl SourceSecretResolver for StubResolver { async fn resolve(&self, name: &str, _src: &SecretSource) -> Result { if self.missing == Some(name) { return Err(AuthError::MissingSecret(name.to_string())); diff --git a/crates/submilli-blueprint/src/edit.rs b/crates/submilli-blueprint/src/edit.rs index e53e58def..16218e4ae 100644 --- a/crates/submilli-blueprint/src/edit.rs +++ b/crates/submilli-blueprint/src/edit.rs @@ -25,9 +25,12 @@ use std::ops::RangeInclusive; use serde_json::Value; -use crate::filter::{self, VarBindings}; -use crate::permissions::{Action, PermissionRule, ResolutionCause, RuleRef}; -use crate::{Blueprint, BlueprintError, VariableDecl}; +use submilli_policy::filter_syntax as filter; + +use crate::{ + Action, Blueprint, BlueprintError, PermissionRule, ResolutionCause, RuleRef, VarBindings, + VariableDecl, +}; /// The refused call a rule is drafted from. #[derive(Debug, Clone, Copy)] diff --git a/crates/submilli-blueprint/src/endpoint.rs b/crates/submilli-blueprint/src/endpoint.rs index 3c2e02201..6d21d12cc 100644 --- a/crates/submilli-blueprint/src/endpoint.rs +++ b/crates/submilli-blueprint/src/endpoint.rs @@ -12,8 +12,8 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; use url::Url; -use crate::auth_proxy::secret_refs; use crate::{Blueprint, Fault, FieldMatch, yaml_path}; +use submilli_policy::secret_refs; /// Host names that always mean this machine, whatever DNS says. Mirrors the /// loopback set the server's MCP endpoint keeps diff --git a/crates/submilli-blueprint/src/lib.rs b/crates/submilli-blueprint/src/lib.rs index 52d3eb3d6..c66a0cd40 100644 --- a/crates/submilli-blueprint/src/lib.rs +++ b/crates/submilli-blueprint/src/lib.rs @@ -6,7 +6,6 @@ pub mod diff; mod edit; mod embedding; mod endpoint; -mod filter; mod git; mod llm; mod locate; @@ -26,8 +25,7 @@ use serde::ser::SerializeMap; use serde::{Deserialize, Serialize, Serializer, de}; pub use auth_proxy::{ - AuthError, AuthProxyRule, AuthSpec, BasicAuth, Injections, SecretResolver, interpolate, - resolve_injections, secret_refs, verify_secrets, + DeclaredSecrets, SourceSecretResolver, interpolate, resolve_injections, verify_secrets, }; pub use diag::{Fault, PathSeg, YamlPath}; pub use edit::{Draft, DraftCall, DraftError, draft_allow}; @@ -35,21 +33,21 @@ pub use embedding::{ EmbeddingConfig, EmbeddingModelDecl, EmbeddingProviderDecl, EmbeddingProviderType, limits as embedding_limits, }; -pub use filter::{ - ComparisonFailure, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, VarBindings, -}; pub use git::{GitConfig, GitIdentity}; pub use llm::{LlmConfig, LlmModelDecl, LlmProviderDecl}; pub use locate::{Citation, RuleLocation, locate_key, locate_rule}; pub use mcp::{McpAuth, McpServer}; -pub use permissions::{ - Action, DefaultAction, NearMiss, PermissionRule, Resolution, ResolutionCause, RuleRef, -}; pub use secrets::{ HarnessSecret, HarnessSecretBindings, HarnessSecretError, SecretSource, required_harness_secrets, resolve_harness_secrets, }; -pub use variables::{VariableDecl, VariableError, resolve_variables}; +use submilli_policy::serde_support::Reject; +pub use submilli_policy::{ + Action, AuthError, AuthProxyPolicy, AuthProxyRule, AuthSpec, BasicAuth, ComparisonFailure, + DefaultAction, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, Injections, NearMiss, + PermissionRule, Policy, Resolution, ResolutionCause, RuleRef, VarBindings, VariableDecl, + VariableError, resolve_variables, secret_refs, +}; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] #[serde(deny_unknown_fields)] @@ -189,7 +187,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> (Action, Option) { - permissions::resolve_with_rule( + submilli_policy::resolve_with_rule( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -210,7 +208,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> Resolution { - permissions::explain( + submilli_policy::explain( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -227,7 +225,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> Action { - permissions::resolve( + submilli_policy::resolve( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -236,6 +234,23 @@ impl Blueprint { vars, ) } + + /// The `permissions:` block and `default:` as a format-neutral [`Policy`]. + pub fn policy(&self) -> Policy { + Policy { + rules: self.permissions.clone(), + default: self.default_action.unwrap_or_default(), + } + } + + /// The `auth_proxy:` block and the blueprint-wide cleartext opt-in as a + /// format-neutral [`AuthProxyPolicy`]. + pub fn auth_proxy_policy(&self) -> AuthProxyPolicy { + AuthProxyPolicy { + allow_insecure_http: self.allow_insecure_http, + rules: self.auth_proxy.clone(), + } + } } fn default_idle_timeout() -> Duration { @@ -713,88 +728,6 @@ impl<'de, S: de::DeserializeSeed<'de>> de::DeserializeSeed<'de> for Guarded { } } -/// A map value whose deserialization always fails, standing in for a value of -/// type `T` so it can replace any field's seed. -/// -/// Raising the error from *inside* the value is what anchors the diagnostic at -/// that key: an error returned from [`VfsVisitor::visit_map`] itself carries -/// only the `vfs:` path, which is too coarse for an editor to squiggle the -/// offending line. Failing from within the visitor rather than after consuming -/// the node also keeps the YAML parser's mark on the value, so the reported -/// line is the offending one and not the first line of the block. -struct Reject(String, PhantomData); - -impl Reject { - fn new(message: impl Into) -> Self { - Reject(message.into(), PhantomData) - } - - fn fail(self) -> Result { - Err(de::Error::custom(self.0)) - } -} - -impl<'de, T> de::DeserializeSeed<'de> for Reject { - type Value = T; - - fn deserialize(self, deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - deserializer.deserialize_any(self) - } -} - -// Every shape of value gets the same message; the default `Visitor` methods -// would replace it with serde's own `invalid type` wording. -impl<'de, T> de::Visitor<'de> for Reject { - type Value = T; - - fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(&self.0) - } - - fn visit_bool(self, _: bool) -> Result { - self.fail() - } - - fn visit_i64(self, _: i64) -> Result { - self.fail() - } - - fn visit_u64(self, _: u64) -> Result { - self.fail() - } - - fn visit_f64(self, _: f64) -> Result { - self.fail() - } - - fn visit_str(self, _: &str) -> Result { - self.fail() - } - - fn visit_bytes(self, _: &[u8]) -> Result { - self.fail() - } - - fn visit_unit(self) -> Result { - self.fail() - } - - fn visit_seq>(self, _: A) -> Result { - self.fail() - } - - fn visit_map>(self, _: A) -> Result { - self.fail() - } - - fn visit_enum>(self, _: A) -> Result { - self.fail() - } -} - /// Reads `volume:` as a non-empty string, anchoring both the wrong-type and the /// empty-name diagnostic at the `volume` key. Goes through `deserialize_any` so /// a non-string scalar is refused rather than silently read as its YAML text: diff --git a/crates/submilli-blueprint/src/maps.rs b/crates/submilli-blueprint/src/maps.rs index 2c7207265..0d6cbaee9 100644 --- a/crates/submilli-blueprint/src/maps.rs +++ b/crates/submilli-blueprint/src/maps.rs @@ -1,39 +1,3 @@ -use std::collections::BTreeMap; -use std::fmt; -use std::marker::PhantomData; +//! Name-keyed blueprint maps reject a repeated key instead of keeping the last. -use serde::{Deserialize, Deserializer, de}; - -/// Name-keyed blueprint maps must not silently replace an earlier declaration. -pub(crate) fn deserialize<'de, D, V>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, - V: Deserialize<'de>, -{ - deserializer.deserialize_map(UniqueNames(PhantomData)) -} - -struct UniqueNames(PhantomData); - -impl<'de, V: Deserialize<'de>> de::Visitor<'de> for UniqueNames { - type Value = BTreeMap; - - fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - formatter.write_str("a map with unique names") - } - - fn visit_map>(self, mut map: A) -> Result { - let mut names = BTreeMap::new(); - while let Some(name) = map.next_key::()? { - if names.contains_key(&name) { - map.next_value_seed(crate::Reject::::new(format!( - "duplicate key `{name}`: remove or rename the repeated declaration" - )))?; - continue; - } - let value = map.next_value()?; - names.insert(name, value); - } - Ok(names) - } -} +pub(crate) use submilli_policy::serde_support::unique_map as deserialize; diff --git a/crates/submilli-blueprint/src/mcp.rs b/crates/submilli-blueprint/src/mcp.rs index 7eb5d4fe0..7d3dd0f5e 100644 --- a/crates/submilli-blueprint/src/mcp.rs +++ b/crates/submilli-blueprint/src/mcp.rs @@ -13,8 +13,8 @@ use std::collections::BTreeMap; use serde::{Deserialize, Serialize}; -use crate::auth_proxy::secret_refs; use crate::{Blueprint, BlueprintError, Fault, yaml_path}; +use submilli_policy::secret_refs; const CAPABILITY_PREFIX: &str = "mcp."; const DEFAULT_TRANSPORT: &str = "streamable_http"; diff --git a/crates/submilli-blueprint/src/permissions.rs b/crates/submilli-blueprint/src/permissions.rs index e6a1f15b2..0c5bc239b 100644 --- a/crates/submilli-blueprint/src/permissions.rs +++ b/crates/submilli-blueprint/src/permissions.rs @@ -1,70 +1,13 @@ -//! The blueprint `permissions:` block — the per-caller capability rules the -//! semantic-security engine evaluates. Keyed by caller identifier (`main` for -//! the user script, package name for library code), each caller maps to an -//! ordered rule list walked top-to-bottom, first-match-wins. A caller absent -//! from the map — or a caller whose rules all miss — falls through to the -//! top-level `default`. -//! -//! Each rule's optional `filter` is a [`FilterExpr`] from [`crate::filter`], -//! parsed at registration time so a malformed filter fails when the blueprint is -//! added rather than at the first `check()`. +//! The blueprint `permissions:` block. The rules and their evaluation live in +//! `submilli-policy`; this checks what serde cannot, with the YAML path of the +//! offending key. use std::collections::BTreeMap; -use serde::{Deserialize, Serialize}; +use submilli_policy::PermissionRule; -use crate::filter::{ComparisonFailure, FilterExpr, VarBindings}; use crate::{BlueprintError, Fault, yaml_path}; -/// Fall-through action when no rule matches. Absent in the blueprint, it -/// defaults to `Deny` (deny-by-default): a policy-free blueprint denies every -/// capability. `allow` flips the posture to allow-by-default — every capability -/// is permitted unless a rule denies it — for trusted deployments that prefer a -/// blocklist over an allowlist. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] -#[serde(rename_all = "kebab-case")] -pub enum DefaultAction { - #[default] - Deny, - Allow, - AskHuman, -} - -/// The action a matched rule (or the fall-through default) resolves to. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "kebab-case")] -pub enum Action { - Allow, - Deny, - AskHuman, -} - -impl From for Action { - fn from(d: DefaultAction) -> Self { - match d { - DefaultAction::Deny => Action::Deny, - DefaultAction::Allow => Action::Allow, - DefaultAction::AskHuman => Action::AskHuman, - } - } -} - -/// One capability rule. The capability name is matched verbatim (no wildcards); -/// flexibility lives in the optional `filter`. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct PermissionRule { - /// Label decisions cite this rule by. Unique within a caller block - /// (`blueprint lint` enforces it); the rule's position identifies it - /// otherwise. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub name: Option, - pub capability: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub filter: Option, - pub action: Action, -} - /// Structural checks beyond what serde already enforces (malformed filters are /// rejected at deserialize time); this catches the empty caller / capability /// cases serde can't express. @@ -96,412 +39,10 @@ pub(crate) fn validate( Ok(()) } -/// Walk the rules for `caller` and return the resolved action. No caller block, -/// or no rule matching `(capability, ctx)`, falls through to `default`. -pub(crate) fn resolve( - permissions: &BTreeMap>, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> Action { - resolve_with_rule(permissions, default_action, caller, capability, ctx, vars).0 -} - -pub(crate) fn resolve_with_rule( - permissions: &BTreeMap>, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> (Action, Option) { - if let Some(rules) = permissions.get(caller) { - for (index, rule) in rules.iter().enumerate() { - if rule.capability == capability - && rule - .filter - .as_ref() - .is_none_or(|f| f.matches_with(ctx, vars)) - { - return (rule.action, Some(index)); - } - } - } - (default_action.into(), None) -} - -/// A resolved decision with the reasoning behind it. -#[derive(Debug, Clone, PartialEq, Serialize)] -pub struct Resolution { - /// Identical to what [`resolve`] returns for the same inputs. - pub action: Action, - pub cause: ResolutionCause, - /// Rules for the capability, ahead of the deciding rule (or all of them - /// when the default decided), whose filters rejected the call. - pub near_misses: Vec, -} - -#[derive(Debug, Clone, PartialEq, Serialize)] -#[serde(rename_all = "kebab-case", tag = "kind")] -pub enum ResolutionCause { - Rule(RuleRef), - /// No rule matched. `caller_block` is whether the caller has any rules. - Default { - caller_block: bool, - }, -} - -/// A rule located by caller block and zero-based position, with its name when -/// it has one. -#[derive(Debug, Clone, PartialEq, Eq, Serialize)] -pub struct RuleRef { - pub caller: String, - pub index: usize, - pub name: Option, -} - -/// A rule that named the right capability but whose filter rejected the call. -#[derive(Debug, Clone, PartialEq, Serialize)] -pub struct NearMiss { - pub rule: RuleRef, - /// The rule's whole filter, from its `Display` impl. - pub filter: String, - pub failures: Vec, -} - -pub(crate) fn explain( - permissions: &BTreeMap>, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> Resolution { - let (action, matched) = - resolve_with_rule(permissions, default_action, caller, capability, ctx, vars); - let rules = permissions.get(caller); - let rule_ref = |index: usize, rule: &PermissionRule| RuleRef { - caller: caller.to_string(), - index, - name: rule.name.clone(), - }; - let cause = match matched.and_then(|index| Some((index, rules?.get(index)?))) { - Some((index, rule)) => ResolutionCause::Rule(rule_ref(index, rule)), - None => ResolutionCause::Default { - caller_block: rules.is_some(), - }, - }; - let walked = matched.unwrap_or(usize::MAX); - let near_misses = rules - .into_iter() - .flatten() - .enumerate() - .take_while(|(index, _)| *index < walked) - .filter(|(_, rule)| rule.capability == capability) - .filter_map(|(index, rule)| { - let filter = rule.filter.as_ref()?; - let evaluation = filter.explain_with(ctx, vars); - (!evaluation.matched).then(|| NearMiss { - rule: rule_ref(index, rule), - filter: filter.to_string(), - failures: evaluation.failures, - }) - }) - .collect(); - Resolution { - action, - cause, - near_misses, - } -} - #[cfg(test)] mod tests { use super::*; - use serde_json::json; - - fn filter(s: &str) -> FilterExpr { - crate::filter::parse(s).expect("valid filter") - } - - #[test] - fn resolve_first_match_wins() { - let mut perms = BTreeMap::new(); - perms.insert( - "main".to_string(), - vec![ - PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: Some(filter("amount < 500")), - action: Action::Allow, - }, - PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: None, - action: Action::AskHuman, - }, - ], - ); - let allow = resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/charge", - &json!({ "amount": 100 }), - &VarBindings::new(), - ); - assert_eq!(allow, Action::Allow); - let ask = resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/charge", - &json!({ "amount": 900 }), - &VarBindings::new(), - ); - assert_eq!(ask, Action::AskHuman); - } - - #[test] - fn resolve_falls_through_to_default() { - let perms = BTreeMap::new(); - // Caller absent entirely. - assert_eq!( - resolve( - &perms, - DefaultAction::Deny, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::Deny - ); - assert_eq!( - resolve( - &perms, - DefaultAction::AskHuman, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::AskHuman - ); - assert_eq!( - resolve( - &perms, - DefaultAction::Allow, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::Allow - ); - } - - #[test] - fn resolve_capability_is_exact() { - let mut perms = BTreeMap::new(); - perms.insert( - "main".to_string(), - vec![PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: None, - action: Action::Allow, - }], - ); - // No wildcard: a sibling capability falls through to default. - assert_eq!( - resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/refund", - &json!({}), - &VarBindings::new() - ), - Action::Deny - ); - } - - fn rule( - name: Option<&str>, - capability: &str, - f: Option<&str>, - action: Action, - ) -> PermissionRule { - PermissionRule { - name: name.map(str::to_string), - capability: capability.into(), - filter: f.map(filter), - action, - } - } - - fn vars(pairs: &[(&str, &str)]) -> VarBindings { - pairs - .iter() - .map(|(k, v)| (k.to_string(), v.to_string())) - .collect() - } - - fn explain_main( - rules: Vec, - default: DefaultAction, - capability: &str, - ctx: serde_json::Value, - bindings: &VarBindings, - ) -> Resolution { - let perms = BTreeMap::from([("main".to_string(), rules)]); - let resolution = explain(&perms, default, "main", capability, &ctx, bindings); - // The explanation never disagrees with enforcement. - assert_eq!( - resolution.action, - resolve(&perms, default, "main", capability, &ctx, bindings) - ); - resolution - } - - #[test] - fn explain_filter_miss_is_a_near_miss_under_default() { - let resolution = explain_main( - vec![rule( - Some("own-customer"), - "acme.com/charges.list", - Some("customerId == ${vars.customerId}"), - Action::Allow, - )], - DefaultAction::Deny, - "acme.com/charges.list", - json!({ "customerId": "cus_initech" }), - &vars(&[("customerId", "cus_northwind")]), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Default { caller_block: true } - ); - let [miss] = resolution.near_misses.as_slice() else { - panic!("expected one near miss: {resolution:?}"); - }; - assert_eq!(miss.rule.index, 0); - assert_eq!(miss.rule.name.as_deref(), Some("own-customer")); - assert_eq!(miss.filter, "customerId == ${vars.customerId}"); - let [failure] = miss.failures.as_slice() else { - panic!("expected one failure: {miss:?}"); - }; - assert_eq!(failure.comparison, "customerId == ${vars.customerId}"); - assert_eq!(failure.actual, Some(json!("cus_initech"))); - assert_eq!(failure.expected.as_deref(), Some("cus_northwind")); - } - - #[test] - fn explain_second_rule_match_cites_index_and_name() { - let resolution = explain_main( - vec![ - rule( - None, - "stripe.com/charge", - Some("amount < 500"), - Action::Allow, - ), - rule(Some("big-charges"), "stripe.com/charge", None, Action::Deny), - ], - DefaultAction::Allow, - "stripe.com/charge", - json!({ "amount": 900 }), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Rule(RuleRef { - caller: "main".into(), - index: 1, - name: Some("big-charges".into()), - }) - ); - // The earlier rule that rejected the call is still reported. - assert_eq!(resolution.near_misses.len(), 1); - assert_eq!(resolution.near_misses[0].rule.index, 0); - assert_eq!(resolution.near_misses[0].rule.name, None); - } - - #[test] - fn explain_without_caller_block_reports_it() { - let perms = BTreeMap::new(); - let resolution = explain( - &perms, - DefaultAction::Deny, - "main", - "x", - &json!({}), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Default { - caller_block: false - } - ); - assert!(resolution.near_misses.is_empty()); - } - - #[test] - fn explain_ask_human_stays_distinct_and_names_the_rule() { - let resolution = explain_main( - vec![rule( - Some("review-refunds"), - "stripe.com/refund", - None, - Action::AskHuman, - )], - DefaultAction::Deny, - "stripe.com/refund", - json!({}), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::AskHuman); - let ResolutionCause::Rule(rule) = &resolution.cause else { - panic!("expected a rule cause: {resolution:?}"); - }; - assert_eq!(rule.name.as_deref(), Some("review-refunds")); - } - - #[test] - fn explain_unbound_variable_failure() { - let resolution = explain_main( - vec![rule(None, "x", Some("id == ${vars.x}"), Action::Allow)], - DefaultAction::Deny, - "x", - json!({ "id": "a" }), - &VarBindings::new(), - ); - assert_eq!( - resolution.near_misses[0].failures[0].reason, - crate::filter::FailureReason::VariableNotBound("x".into()) - ); - } - - #[test] - fn explain_ignores_other_capabilities() { - let resolution = explain_main( - vec![rule(None, "a", Some("n == 1"), Action::Allow)], - DefaultAction::Deny, - "b", - json!({ "n": 2 }), - &VarBindings::new(), - ); - assert!(resolution.near_misses.is_empty()); - } + use submilli_policy::Action; #[test] fn rule_name_is_optional_and_unknown_fields_still_rejected() { @@ -525,7 +66,12 @@ mod tests { fn empty_rule_name_is_invalid() { let perms = BTreeMap::from([( "main".to_string(), - vec![rule(Some(""), "a", None, Action::Allow)], + vec![PermissionRule { + name: Some(String::new()), + capability: "a".into(), + filter: None, + action: Action::Allow, + }], )]); assert!(validate(&perms).is_err()); } diff --git a/crates/submilli-blueprint/src/variables.rs b/crates/submilli-blueprint/src/variables.rs index 435f7573d..77a4b63a6 100644 --- a/crates/submilli-blueprint/src/variables.rs +++ b/crates/submilli-blueprint/src/variables.rs @@ -9,56 +9,8 @@ //! REST `/v1/execute` path and the MCP `initialize` path run before a session is //! allowed to open. -use std::collections::BTreeMap; -use std::fmt; - -use serde::{Deserialize, Serialize}; - use crate::{Blueprint, BlueprintError, Fault, yaml_path}; -/// One declared variable. `required` and `default` are mutually exclusive: a -/// required variable with a default is contradictory (rejected at parse). -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct VariableDecl { - /// The session is rejected at init if this variable is missing or empty. - #[serde(default, skip_serializing_if = "is_false")] - pub required: bool, - /// Value bound when the caller supplies none. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub default: Option, -} - -fn is_false(b: &bool) -> bool { - !*b -} - -/// A failure binding caller-supplied variables against the blueprint's -/// declarations, surfaced at session init (REST → 400, MCP → failed -/// `initialize`). -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum VariableError { - /// A `required` variable was not supplied (or supplied empty). - MissingRequired(String), - /// A supplied variable name is not declared in the blueprint. - Unknown(String), -} - -impl fmt::Display for VariableError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - VariableError::MissingRequired(name) => { - write!(f, "required variable '{name}' was not supplied") - } - VariableError::Unknown(name) => { - write!(f, "variable '{name}' is not declared in the blueprint") - } - } - } -} - -impl std::error::Error for VariableError {} - /// Parse-time structural checks: `required`+`default` is contradictory, and /// every `${vars.NAME}` a permission filter references must name a declared /// variable. Declared-but-unused variables are allowed (no warning channel; @@ -93,43 +45,12 @@ pub(crate) fn validate_variables(blueprint: &Blueprint) -> Result<(), BlueprintE Ok(()) } -/// Bind caller-supplied values against the declarations: fill defaults, reject a -/// missing/empty `required` variable, reject any supplied name that isn't -/// declared. Returns the resolved bindings filter evaluation reads. An optional -/// variable with no value and no default is simply omitted — an absent -/// `${vars.NAME}` is a non-match at eval, never a trap. -pub fn resolve_variables( - decls: &BTreeMap, - supplied: &BTreeMap, -) -> Result, VariableError> { - for name in supplied.keys() { - if !decls.contains_key(name) { - return Err(VariableError::Unknown(name.clone())); - } - } - let mut resolved = BTreeMap::new(); - for (name, decl) in decls { - match supplied.get(name) { - Some(value) if !value.is_empty() => { - resolved.insert(name.clone(), value.clone()); - } - _ => { - if decl.required { - return Err(VariableError::MissingRequired(name.clone())); - } - if let Some(default) = &decl.default { - resolved.insert(name.clone(), default.clone()); - } - } - } - } - Ok(resolved) -} - #[cfg(test)] mod tests { + use std::collections::BTreeMap; + use super::*; - use crate::parse; + use crate::{VariableDecl, VariableError, parse, resolve_variables}; fn decls(yaml: &str) -> BTreeMap { parse(yaml).expect("valid blueprint").variables diff --git a/crates/submilli-policy/Cargo.toml b/crates/submilli-policy/Cargo.toml new file mode 100644 index 000000000..f57062290 --- /dev/null +++ b/crates/submilli-policy/Cargo.toml @@ -0,0 +1,30 @@ +[package] +name = "submilli-policy" +version.workspace = true +edition.workspace = true +license.workspace = true +repository.workspace = true +publish.workspace = true + +[lints] +workspace = true + +[lib] +path = "src/lib.rs" + +[dependencies] +serde = { workspace = true, features = ["derive"] } +serde_json = { workspace = true } +regex = { workspace = true } +async-trait = { workspace = true } +base64 = { workspace = true } +interpreter = { path = "../interpreter", optional = true } +url = { workspace = true, optional = true } + +[features] +# Adapters from the policy types to the engine's host-service traits. +engine = ["dep:interpreter", "dep:url"] + +[dev-dependencies] +interpreter = { path = "../interpreter" } +tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/crates/submilli-policy/src/auth_proxy.rs b/crates/submilli-policy/src/auth_proxy.rs new file mode 100644 index 000000000..d56b3c723 --- /dev/null +++ b/crates/submilli-policy/src/auth_proxy.rs @@ -0,0 +1,271 @@ +//! Auth-proxy rules: host-keyed rules that inject auth headers and query +//! parameters into outbound HTTP, with `${secrets.X}` resolved through a +//! [`SecretResolver`]. The program never sees the resolved values. +//! +//! This module computes what to inject; the embedder supplies the resolver and +//! adapts the result to the runtime's `AuthProxy` trait. + +use std::collections::BTreeMap; +use std::fmt; + +use base64::{Engine as _, engine::general_purpose::STANDARD}; +use serde::{Deserialize, Serialize}; + +const PLACEHOLDER_PREFIX: &str = "${secrets."; + +/// Every auth-proxy rule in force, and whether cleartext HTTP may be used at +/// all. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct AuthProxyPolicy { + /// Permit cleartext requests; a rule must opt in separately to inject into + /// one. + pub allow_insecure_http: bool, + pub rules: Vec, +} + +/// One host-keyed injection rule. v1 matches `host` exactly. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AuthProxyRule { + pub host: String, + /// Also requires the policy-wide opt-in to permit cleartext requests. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub allow_insecure_http: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub auth: Option, + #[serde( + default, + skip_serializing_if = "BTreeMap::is_empty", + deserialize_with = "crate::serde_support::unique_map" + )] + pub headers: BTreeMap, + #[serde( + default, + skip_serializing_if = "BTreeMap::is_empty", + deserialize_with = "crate::serde_support::unique_map" + )] + pub query: BTreeMap, +} + +/// A first-class auth method, lowered into an `Authorization` header at resolve +/// time. Exactly one of `bearer`/`basic` is set (the format that reads rules +/// enforces it). `bearer` / basic `password` name declared secrets; basic +/// `username` is a literal. Basic auth can't be expressed as an +/// interpolation-only header value — its `base64(user:pass)` is computed *after* +/// the password secret resolves. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AuthSpec { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub bearer: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub basic: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct BasicAuth { + pub username: String, + pub password: String, +} + +/// Resolves a secret, by name, to its value. Implemented by the embedder, which +/// knows which names are declared and where each value comes from: a name it +/// does not declare is [`AuthError::UndeclaredSecret`]. Async so a store can be +/// awaited without blocking the executor. +#[async_trait::async_trait] +pub trait SecretResolver: Send + Sync { + async fn resolve(&self, name: &str) -> Result; +} + +/// What an auth-proxy rule contributes to a request. Header/query *names* are +/// taken verbatim; values have their `${secrets.X}` placeholders resolved. +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct Injections { + pub headers: Vec<(String, String)>, + pub query: Vec<(String, String)>, +} + +/// Runtime auth-proxy failure. Maps onto the runtime's `AuthProxyError`. +#[derive(Debug)] +pub enum AuthError { + /// `${secrets.X}` referenced an undeclared name. + UndeclaredSecret(String), + /// Secret declared but its source produced no value. + MissingSecret(String), + Other(String), +} + +impl fmt::Display for AuthError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AuthError::UndeclaredSecret(name) => write!(f, "undeclared secret '{name}'"), + AuthError::MissingSecret(name) => write!(f, "missing secret '{name}'"), + AuthError::Other(msg) => f.write_str(msg), + } + } +} + +impl std::error::Error for AuthError {} + +/// The `${secrets.NAME}` names referenced by a value, in order. +pub fn secret_refs(value: &str) -> Vec<&str> { + let mut names = Vec::new(); + let mut rest = value; + while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { + let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; + match after.find('}') { + Some(end) => { + names.push(&after[..end]); + rest = &after[end + 1..]; + } + None => break, + } + } + names +} + +/// The first rule whose `host` matches exactly, with `${secrets.X}` resolved. +/// `Ok(None)` when no rule matches. +pub async fn resolve_injections( + rules: &[AuthProxyRule], + host: &str, + resolver: &dyn SecretResolver, +) -> Result, AuthError> { + let Some(rule) = rules.iter().find(|r| r.host == host) else { + return Ok(None); + }; + let mut headers = interpolate_pairs(&rule.headers, resolver).await?; + if let Some(auth) = &rule.auth { + headers.push(( + "Authorization".to_string(), + resolve_authorization(auth, resolver).await?, + )); + } + Ok(Some(Injections { + headers, + query: interpolate_pairs(&rule.query, resolver).await?, + })) +} + +/// The `Authorization` header value for an `auth:` method: `Bearer ` or +/// `Basic `. `bearer`/`password` name declared secrets and +/// are resolved directly (not `${secrets.X}` interpolation). +async fn resolve_authorization( + auth: &AuthSpec, + resolver: &dyn SecretResolver, +) -> Result { + if let Some(secret) = &auth.bearer { + return Ok(format!("Bearer {}", resolver.resolve(secret).await?)); + } + if let Some(basic) = &auth.basic { + let password = resolver.resolve(&basic.password).await?; + let token = STANDARD.encode(format!("{}:{password}", basic.username)); + return Ok(format!("Basic {token}")); + } + Err(AuthError::Other( + "auth_proxy rule has an empty `auth:` block".into(), + )) +} + +async fn interpolate_pairs( + pairs: &BTreeMap, + resolver: &dyn SecretResolver, +) -> Result, AuthError> { + let mut out = Vec::with_capacity(pairs.len()); + for (name, value) in pairs { + out.push((name.clone(), interpolate(value, resolver).await?)); + } + Ok(out) +} + +/// Replace every `${secrets.NAME}` in `value` with its resolved secret. Public so +/// other settings that interpolate secrets can reuse the exact placeholder +/// semantics auth-proxy rules use. +pub async fn interpolate(value: &str, resolver: &dyn SecretResolver) -> Result { + let mut out = String::new(); + let mut rest = value; + while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { + out.push_str(&rest[..start]); + let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; + let end = after.find('}').ok_or_else(|| { + AuthError::Other(format!( + "unterminated '{PLACEHOLDER_PREFIX}...}}' in '{value}'" + )) + })?; + out.push_str(&resolver.resolve(&after[..end]).await?); + rest = &after[end + 1..]; + } + out.push_str(rest); + Ok(out) +} + +#[cfg(test)] +mod tests { + use super::*; + + /// Knows `K` and `P`, resolving each to `"-value"`. + struct Stub; + + #[async_trait::async_trait] + impl SecretResolver for Stub { + async fn resolve(&self, name: &str) -> Result { + match name { + "K" | "P" => Ok(format!("{name}-value")), + _ => Err(AuthError::UndeclaredSecret(name.to_string())), + } + } + } + + fn rule(host: &str) -> AuthProxyRule { + AuthProxyRule { + host: host.to_string(), + allow_insecure_http: false, + auth: None, + headers: BTreeMap::new(), + query: BTreeMap::new(), + } + } + + #[tokio::test] + async fn rules_resolve_by_name_without_a_blueprint() { + let rules = vec![ + AuthProxyRule { + headers: BTreeMap::from([("X-Key".to_string(), "k=${secrets.K}".to_string())]), + auth: Some(AuthSpec { + bearer: None, + basic: Some(BasicAuth { + username: "alice".to_string(), + password: "P".to_string(), + }), + }), + ..rule("h") + }, + rule("other"), + ]; + let injections = resolve_injections(&rules, "h", &Stub) + .await + .expect("resolves") + .expect("rule matches"); + let basic = STANDARD.encode("alice:P-value"); + assert_eq!( + injections.headers, + [ + ("X-Key".to_string(), "k=K-value".to_string()), + ("Authorization".to_string(), format!("Basic {basic}")), + ] + ); + assert!( + resolve_injections(&rules, "none", &Stub) + .await + .expect("ok") + .is_none() + ); + } + + #[tokio::test] + async fn an_undeclared_name_surfaces_from_the_resolver() { + let err = interpolate("${secrets.NOPE}", &Stub).await.unwrap_err(); + assert!(matches!(err, AuthError::UndeclaredSecret(name) if name == "NOPE")); + } +} diff --git a/crates/submilli-blueprint/src/filter.rs b/crates/submilli-policy/src/filter.rs similarity index 99% rename from crates/submilli-blueprint/src/filter.rs rename to crates/submilli-policy/src/filter.rs index c59fe1f97..5d47252db 100644 --- a/crates/submilli-blueprint/src/filter.rs +++ b/crates/submilli-policy/src/filter.rs @@ -308,7 +308,8 @@ impl FilterExpr { /// The top-level `and` operands, flattened: `a and (b and c)` yields `a`, `b`, /// `c`. A filter that is not an `and` is its own single conjunct. - pub(crate) fn conjuncts(&self) -> Vec<&FilterExpr> { + #[doc(hidden)] + pub fn conjuncts(&self) -> Vec<&FilterExpr> { let mut out = Vec::new(); self.collect_flat(&mut out, |expr| match expr { Expr::And(left, right) => Some((left, right)), @@ -318,7 +319,8 @@ impl FilterExpr { } /// The top-level `or` operands, flattened like [`Self::conjuncts`]. - pub(crate) fn disjuncts(&self) -> Vec<&FilterExpr> { + #[doc(hidden)] + pub fn disjuncts(&self) -> Vec<&FilterExpr> { let mut out = Vec::new(); self.collect_flat(&mut out, |expr| match expr { Expr::Or(left, right) => Some((left, right)), @@ -343,7 +345,8 @@ impl FilterExpr { /// `(field path, variable)` when this expression is exactly /// `field == ${vars.NAME}`: the shape that pins a rule to a session variable. - pub(crate) fn as_pin(&self) -> Option<(String, &str)> { + #[doc(hidden)] + pub fn as_pin(&self) -> Option<(String, &str)> { match &self.0 { Expr::Compare(Comparison { path, @@ -721,13 +724,15 @@ fn glob_token(pat: &[char], pi: usize) -> Option<(GlobToken, usize)> { /// `value` as a quoted string literal that parses back to exactly `value`, or /// `None` when no literal can: the tokenizer reads any `${vars.` inside quotes /// as a variable placeholder and has no escape for it. -pub(crate) fn quote_literal(value: &str) -> Option { +#[doc(hidden)] +pub fn quote_literal(value: &str) -> Option { (!value.contains(VAR_PLACEHOLDER)).then(|| format!("\"{}\"", escape_str(value))) } /// True when `name` is written as a bare comparison field: one path segment /// the tokenizer reads as a field rather than a keyword or literal. -pub(crate) fn is_field_name(name: &str) -> bool { +#[doc(hidden)] +pub fn is_field_name(name: &str) -> bool { let mut chars = name.chars(); chars .next() @@ -808,7 +813,8 @@ enum Token { } /// True for a syntactically valid `${vars.NAME}` variable name. -pub(crate) fn is_valid_var_name(name: &str) -> bool { +#[doc(hidden)] +pub fn is_valid_var_name(name: &str) -> bool { !name.is_empty() && name .chars() @@ -1271,7 +1277,8 @@ fn parse_filter(raw: &str) -> Result { /// Parse a filter expression, rendering any error to a caret-annotated string. /// The crate-internal entry point used by the serde impl (and tests). -pub(crate) fn parse(raw: &str) -> Result { +#[doc(hidden)] +pub fn parse(raw: &str) -> Result { // Reject before tokenization or diagnostic rendering copies the input. if raw.len() > MAX_FILTER_BYTES { return Err(format!( diff --git a/crates/submilli-policy/src/host.rs b/crates/submilli-policy/src/host.rs new file mode 100644 index 000000000..5f3ab1020 --- /dev/null +++ b/crates/submilli-policy/src/host.rs @@ -0,0 +1,468 @@ +//! Adapters from a [`Policy`] and an [`AuthProxyPolicy`] to the engine's +//! host-service traits ([`SecurityCheck`], [`AuthProxy`], [`SecretProvider`]), +//! for an embedder to install on a store. Behind the `engine` feature, so the +//! policy types themselves stay free of the engine. + +use std::borrow::Cow; +use std::collections::BTreeMap; +use std::sync::Arc; + +use async_trait::async_trait; +use interpreter::runtime::{ + AuthProxy, AuthProxyError, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, + FailureReasonRecord, FailureRecord, HttpRequest, NearMissRecord, RuleCitation, SecretProvider, + SecurityCheck, +}; +use interpreter::stdlib::http::HttpTransportPolicy; +use url::Url; + +use crate::{ + Action, AuthError, AuthProxyPolicy, AuthProxyRule, ComparisonFailure, FailureReason, + Injections, NearMiss, Policy, Resolution, ResolutionCause, RuleRef, SecretResolver, + VarBindings, resolve_injections, +}; + +/// The package name auth-proxy injection is scoped to. Matches the name the runtime gives a +/// user script's module, which is what it reads off the running wasm frame to identify a +/// caller. +const MAIN_PACKAGE: &str = "main"; + +// ---- SecurityCheck ------------------------------------------------------- + +/// [`Policy`]-driven [`SecurityCheck`]: evaluates the permission rules for each +/// capability check. +/// +/// Deny-by-default: a capability is allowed only when a rule says so, and a +/// policy with no rules and a `Deny` default denies every capability. An +/// `Allow` default inverts this to allow-by-default. `ask-human` +/// is deferred (no suspend/resume yet), so it resolves to `Deny` with a reason +/// that says so. +/// +/// Filesystem rules see absolute guest paths with `.` and `..` collapsed using +/// the same lexical resolver as VFS I/O. This also applies to both endpoints of +/// copy/move and the destination of HTTP downloads. It does not resolve symlinks. +pub struct PolicyCheck { + policy: Arc, + /// Caller-supplied `${vars.NAME}` bindings for this session, resolved at + /// session init. Empty for callers that bind no variables. + variables: Arc, +} + +impl PolicyCheck { + pub fn new(policy: Arc) -> Self { + Self::with_variables(policy, Arc::new(BTreeMap::new())) + } + + /// As [`Self::new`], with the session's resolved variable bindings threaded + /// into every `${vars.NAME}` filter operand. + pub fn with_variables(policy: Arc, variables: Arc) -> Self { + PolicyCheck { policy, variables } + } +} + +impl SecurityCheck for PolicyCheck { + fn audit_context<'a>( + &self, + capability: &str, + context: &'a serde_json::Value, + cwd: &str, + ) -> Cow<'a, serde_json::Value> { + filesystem_policy_context(capability, context, cwd).unwrap_or(Cow::Borrowed(context)) + } + + fn check(&self, caller: &str, capability: &str, context: &serde_json::Value) -> CheckOutcome { + self.check_with_cwd(caller, capability, context, "/") + } + + fn explain( + &self, + caller: &str, + capability: &str, + context: &serde_json::Value, + cwd: &str, + ) -> Option { + let context = match filesystem_policy_context(capability, context, cwd) { + Ok(context) => context, + // `check_with_cwd` refuses these before resolution: no rule can grant them. + Err(reason) => { + return Some(DecisionExplanation { + action: DecisionAction::Deny, + cause: DecisionCause::RuntimeInvariant { reason }, + near_misses: Vec::new(), + }); + } + }; + let resolution = self + .policy + .explain(caller, capability, &context, &self.variables); + Some(explanation_of(resolution)) + } + + fn check_with_cwd( + &self, + caller: &str, + capability: &str, + context: &serde_json::Value, + cwd: &str, + ) -> CheckOutcome { + let context = match filesystem_policy_context(capability, context, cwd) { + Ok(context) => context, + Err(reason) => return CheckOutcome::Deny { reason, rule: None }, + }; + let (action, rule) = + self.policy + .resolve_with_rule(caller, capability, &context, &self.variables); + match action { + Action::Allow => CheckOutcome::Allow { rule }, + Action::Deny => CheckOutcome::Deny { + rule, + reason: format!( + "policy denied {capability}{} for {caller}", + filesystem_target(capability, &context) + ), + }, + Action::AskHuman => CheckOutcome::Deny { + rule, + reason: format!( + "policy requires human approval for {capability}{} (caller {caller}); \ + ask-human is deferred and treated as deny", + filesystem_target(capability, &context) + ), + }, + } + } +} + +fn explanation_of(resolution: Resolution) -> DecisionExplanation { + DecisionExplanation { + action: match resolution.action { + Action::Allow => DecisionAction::Allow, + Action::Deny => DecisionAction::Deny, + Action::AskHuman => DecisionAction::AskHuman, + }, + cause: cause_of(resolution.cause), + near_misses: resolution + .near_misses + .into_iter() + .map(near_miss_record) + .collect(), + } +} + +fn citation(rule: RuleRef) -> RuleCitation { + RuleCitation { + caller: rule.caller, + index: rule.index, + name: rule.name, + } +} + +fn cause_of(cause: ResolutionCause) -> DecisionCause { + match cause { + ResolutionCause::Rule(rule) => DecisionCause::Rule(citation(rule)), + ResolutionCause::Default { caller_block } => DecisionCause::Default { caller_block }, + } +} + +fn near_miss_record(miss: NearMiss) -> NearMissRecord { + NearMissRecord { + rule: citation(miss.rule), + filter: miss.filter, + failures: miss.failures.into_iter().map(failure_record).collect(), + } +} + +fn failure_record(failure: ComparisonFailure) -> FailureRecord { + let reason = match failure.reason { + FailureReason::FieldMissing => FailureReasonRecord::FieldMissing, + FailureReason::VariableNotBound(name) => FailureReasonRecord::VariableNotBound(name), + FailureReason::NotSatisfied => FailureReasonRecord::NotSatisfied, + }; + FailureRecord { + comparison: failure.comparison, + actual: failure.actual, + expected: failure.expected, + reason, + negated: failure.negated, + } +} + +/// The normalized VFS paths a denial was for, so a narrowed filter can be fixed +/// from the message. The library may have probed a path on the program's +/// behalf, as `submilli:code` does for ignore files, so the program's own +/// arguments do not always name it. Empty for capabilities without VFS paths. +fn filesystem_target(capability: &str, context: &serde_json::Value) -> String { + let path = |field: &&str| context.get(*field).and_then(serde_json::Value::as_str); + match filesystem_path_fields(capability) { + [single] => path(single).map_or_else(String::new, |path| format!(" on {path}")), + [from, to] => match (path(from), path(to)) { + (Some(from), Some(to)) => format!(" from {from} to {to}"), + _ => String::new(), + }, + _ => String::new(), + } +} + +/// The context fields of a capability that hold VFS paths. +fn filesystem_path_fields(capability: &str) -> &'static [&'static str] { + match capability { + "fs.read" | "fs.write" | "fs.stat" | "fs.list" | "fs.mkdir" | "fs.remove" => &["path"], + "fs.copy" | "fs.move" => &["from", "to"], + "git.init" | "git.clone" | "git.fetch" | "git.commit" => &["path"], + "http.download" => &["vfs_path"], + _ => &[], + } +} + +/// Keep policy paths in the same guest namespace as the subsequent VFS operation. +/// Normalization is lexical and performs no I/O, so a denial cannot reveal whether +/// the target exists. URL paths and application-defined capabilities stay untouched. +fn filesystem_policy_context<'a>( + capability: &str, + context: &'a serde_json::Value, + cwd: &str, +) -> Result, String> { + let fields = filesystem_path_fields(capability); + let mut normalized_context = Cow::Borrowed(context); + for &field in fields { + let path = context + .get(field) + .and_then(serde_json::Value::as_str) + .ok_or_else(|| { + format!("invalid {capability} context: {field} must be a VFS path string") + })?; + let normalized = interpreter::runtime::fs::guest_normalize(cwd, path) + .map_err(|error| format!("invalid {capability} {field}: {error}"))?; + if normalized != path { + normalized_context.to_mut()[field] = serde_json::Value::String(normalized); + } + } + Ok(normalized_context) +} + +// ---- AuthProxy ----------------------------------------------------------- + +/// [`AuthProxy`] backed by an [`AuthProxyPolicy`]. Injects the matching rule's +/// headers / query params (with `${secrets.X}` resolved) into outbound +/// `submilli:http` calls made by `main`. +pub struct PolicyAuthProxy { + transport_policy: Arc, + authenticated_policy: Arc, + rules: Vec, + resolver: Arc, +} + +impl PolicyAuthProxy { + pub fn new(policy: AuthProxyPolicy, resolver: Arc) -> Self { + let transport_policy = HttpTransportPolicy { + allow_insecure_http: policy.allow_insecure_http, + auth_proxy_hosts: policy + .rules + .iter() + .map(|rule| (rule.host.clone(), rule.allow_insecure_http)) + .collect(), + same_origin_redirects: false, + }; + let authenticated_policy = Arc::new(HttpTransportPolicy { + same_origin_redirects: true, + ..transport_policy.clone() + }); + Self { + transport_policy: Arc::new(transport_policy), + authenticated_policy, + rules: policy.rules, + resolver, + } + } +} + +#[async_trait] +impl AuthProxy for PolicyAuthProxy { + async fn transform( + &self, + mut req: HttpRequest, + caller: &str, + ) -> Result { + req.transport_policy = Some(Arc::clone(&self.transport_policy)); + // Check every caller before resolving credentials, including package calls. + let url = + Url::parse(&req.url).map_err(|_| AuthProxyError::Other("invalid HTTP URL".into()))?; + self.transport_policy + .check_destination(&url) + .map_err(|error| AuthProxyError::Other(error.to_string()))?; + if caller != MAIN_PACKAGE { + return Ok(req); + } + let Some(host) = url.host_str() else { + return Ok(req); + }; + let Some(injections) = resolve_injections(&self.rules, host, self.resolver.as_ref()) + .await + .map_err(to_proxy_error)? + else { + return Ok(req); + }; + req.transport_policy = Some(Arc::clone(&self.authenticated_policy)); + apply(&mut req, injections); + Ok(req) + } +} + +/// Apply injections; the policy's value overrides any the program set itself. +fn apply(req: &mut HttpRequest, injections: Injections) { + for (name, value) in injections.headers { + let key = name.to_ascii_lowercase(); // host stores header names lowercased + req.headers.retain(|(k, _)| *k != key); + req.headers.push((key, value)); + } + if !injections.query.is_empty() + && let Ok(url) = Url::parse(&req.url) + { + req.url = with_query(&url, &injections.query); + } +} + +/// Rebuild the URL's query string: keep the program's params except those the +/// policy sets (the policy wins), then append the injected ones. +fn with_query(url: &Url, injected: &[(String, String)]) -> String { + let overridden: Vec<&str> = injected.iter().map(|(k, _)| k.as_str()).collect(); + let kept: Vec<(String, String)> = url + .query_pairs() + .filter(|(k, _)| !overridden.contains(&k.as_ref())) + .map(|(k, v)| (k.into_owned(), v.into_owned())) + .collect(); + let mut out = url.clone(); + { + let mut pairs = out.query_pairs_mut(); + pairs.clear(); + for (k, v) in &kept { + pairs.append_pair(k, v); + } + for (k, v) in injected { + pairs.append_pair(k, v); + } + } + // `query_pairs_mut().clear()` on an originally-empty query leaves a bare `?`. + if out.query() == Some("") { + out.set_query(None); + } + out.to_string() +} + +fn to_proxy_error(err: AuthError) -> AuthProxyError { + match err { + AuthError::UndeclaredSecret(name) => AuthProxyError::UndeclaredSecret(name), + AuthError::MissingSecret(name) => AuthProxyError::MissingSecret(name), + AuthError::Other(msg) => AuthProxyError::Other(msg), + } +} + +// ---- SecretProvider ------------------------------------------------------ + +/// [`SecretProvider`] for the program-visible `submilli:secrets.get`: a secret +/// the resolver does not declare, or that has no value, reads as absent. +pub struct PolicySecretProvider { + resolver: Arc, +} + +impl PolicySecretProvider { + pub fn new(resolver: Arc) -> Self { + Self { resolver } + } +} + +impl SecretProvider for PolicySecretProvider { + fn get<'a>( + &'a self, + name: &'a str, + ) -> std::pin::Pin< + Box, String>> + Send + 'a>, + > { + Box::pin(async move { + match self.resolver.resolve(name).await { + Ok(value) => Ok(Some(value)), + Err(AuthError::UndeclaredSecret(_) | AuthError::MissingSecret(_)) => Ok(None), + Err(AuthError::Other(msg)) => Err(msg), + } + }) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + /// An embedder that keeps policy outside a blueprint installs the same check: + /// rules it built itself, its session variables, and the guest's cwd. + #[test] + fn a_hand_built_policy_checks_normalized_paths_and_variables() { + let policy = Policy { + rules: BTreeMap::from([( + "main".to_string(), + vec![crate::PermissionRule { + name: None, + capability: "fs.read".to_string(), + filter: Some("path glob \"/${vars.user}/*\"".parse().expect("filter")), + action: Action::Allow, + }], + )]), + default: crate::DefaultAction::Deny, + }; + let check = PolicyCheck::with_variables( + Arc::new(policy), + Arc::new(BTreeMap::from([("user".to_string(), "ada".to_string())])), + ); + let read = |path: &str, cwd: &str| { + check.check_with_cwd("main", "fs.read", &serde_json::json!({ "path": path }), cwd) + }; + assert!(matches!( + read("notes.md", "/ada"), + CheckOutcome::Allow { .. } + )); + assert!(matches!( + read("../grace/notes.md", "/ada"), + CheckOutcome::Deny { .. } + )); + } + + #[tokio::test] + async fn the_secret_provider_reads_undeclared_and_missing_secrets_as_absent() { + struct Secrets; + #[async_trait] + impl SecretResolver for Secrets { + async fn resolve(&self, name: &str) -> Result { + match name { + "TOKEN" => Ok("t".to_string()), + "UNSET" => Err(AuthError::MissingSecret(name.to_string())), + "BROKEN" => Err(AuthError::Other("store down".to_string())), + _ => Err(AuthError::UndeclaredSecret(name.to_string())), + } + } + } + let provider = PolicySecretProvider::new(Arc::new(Secrets)); + assert_eq!(provider.get("TOKEN").await, Ok(Some("t".to_string()))); + assert_eq!(provider.get("UNSET").await, Ok(None)); + assert_eq!(provider.get("OTHER").await, Ok(None)); + assert_eq!(provider.get("BROKEN").await, Err("store down".to_string())); + } + + #[test] + fn normalized_policy_paths_are_vfs_path_fields_in_the_catalog() { + use interpreter::stdlib::capabilities::{FieldNormalization, catalog}; + for capability in catalog().iter().flat_map(|group| group.capabilities) { + for field in filesystem_path_fields(capability.name) { + let normalization = capability + .filter_fields + .iter() + .find(|candidate| candidate.name == *field) + .map(|candidate| candidate.normalization); + assert_eq!( + normalization, + Some(FieldNormalization::VfsPath), + "{}.{field}", + capability.name + ); + } + } + } +} diff --git a/crates/submilli-policy/src/lib.rs b/crates/submilli-policy/src/lib.rs new file mode 100644 index 000000000..9dc1256af --- /dev/null +++ b/crates/submilli-policy/src/lib.rs @@ -0,0 +1,36 @@ +//! The Submilli policy engine: permission rules and their filter language, +//! session variables, and auth-proxy injection. +//! +//! Format-neutral: nothing here knows where a policy is written down. A +//! blueprint file is one source (`submilli-blueprint`); an embedder that keeps +//! policy elsewhere builds these types from its own and evaluates them the same +//! way. + +mod auth_proxy; +mod filter; +#[cfg(feature = "engine")] +pub mod host; +mod permissions; +#[doc(hidden)] +pub mod serde_support; +mod variables; + +pub use auth_proxy::{ + AuthError, AuthProxyPolicy, AuthProxyRule, AuthSpec, BasicAuth, Injections, SecretResolver, + interpolate, resolve_injections, secret_refs, +}; +pub use filter::{ + ComparisonFailure, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, VarBindings, +}; +pub use permissions::{ + Action, DefaultAction, NearMiss, PermissionRule, Policy, Resolution, ResolutionCause, RuleRef, + Rules, explain, resolve, resolve_with_rule, +}; +pub use variables::{VariableDecl, VariableError, resolve_variables}; + +/// Tooling over the filter language that is not part of the evaluation API: +/// quoting, name checks and expression structure, for editors and diffs. +#[doc(hidden)] +pub mod filter_syntax { + pub use crate::filter::{is_field_name, is_valid_var_name, parse, quote_literal}; +} diff --git a/crates/submilli-policy/src/permissions.rs b/crates/submilli-policy/src/permissions.rs new file mode 100644 index 000000000..406b5d36d --- /dev/null +++ b/crates/submilli-policy/src/permissions.rs @@ -0,0 +1,553 @@ +//! Permission rules — the per-caller capability rules the semantic-security +//! engine evaluates, the blueprint's `permissions:` block. Keyed by caller identifier (`main` for +//! the user script, package name for library code), each caller maps to an +//! ordered rule list walked top-to-bottom, first-match-wins. A caller absent +//! from the map — or a caller whose rules all miss — falls through to the +//! top-level `default`. +//! +//! Each rule's optional `filter` is a [`FilterExpr`] from [`crate::filter`], +//! parsed when the rules are read, so a malformed filter fails then rather than +//! at the first `check()`. + +use std::collections::BTreeMap; + +use serde::{Deserialize, Serialize}; + +use crate::filter::{ComparisonFailure, FilterExpr, VarBindings}; + +/// Fall-through action when no rule matches. Absent in the blueprint, it +/// defaults to `Deny` (deny-by-default): a policy-free blueprint denies every +/// capability. `allow` flips the posture to allow-by-default — every capability +/// is permitted unless a rule denies it — for trusted deployments that prefer a +/// blocklist over an allowlist. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum DefaultAction { + #[default] + Deny, + Allow, + AskHuman, +} + +/// The action a matched rule (or the fall-through default) resolves to. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum Action { + Allow, + Deny, + AskHuman, +} + +impl From for Action { + fn from(d: DefaultAction) -> Self { + match d { + DefaultAction::Deny => Action::Deny, + DefaultAction::Allow => Action::Allow, + DefaultAction::AskHuman => Action::AskHuman, + } + } +} + +/// One capability rule. The capability name is matched verbatim (no wildcards); +/// flexibility lives in the optional `filter`. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct PermissionRule { + /// Label decisions cite this rule by. Unique within a caller block + /// (`blueprint lint` enforces it); the rule's position identifies it + /// otherwise. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub name: Option, + pub capability: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub filter: Option, + pub action: Action, +} + +/// Every caller's rules, by caller identifier. +pub type Rules = BTreeMap>; + +/// A complete permission policy: the per-caller rules and what applies when +/// none matches. +#[derive(Debug, Clone, Default, PartialEq)] +pub struct Policy { + pub rules: Rules, + pub default: DefaultAction, +} + +impl Policy { + /// See [`resolve`]. + pub fn resolve( + &self, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, + ) -> Action { + resolve(&self.rules, self.default, caller, capability, ctx, vars) + } + + /// See [`resolve_with_rule`]. + pub fn resolve_with_rule( + &self, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, + ) -> (Action, Option) { + resolve_with_rule(&self.rules, self.default, caller, capability, ctx, vars) + } + + /// See [`explain`]. + pub fn explain( + &self, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, + ) -> Resolution { + explain(&self.rules, self.default, caller, capability, ctx, vars) + } +} + +/// Walk the rules for `caller` and return the resolved action. No caller block, +/// or no rule matching `(capability, ctx)`, falls through to `default`. +pub fn resolve( + permissions: &Rules, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> Action { + resolve_with_rule(permissions, default_action, caller, capability, ctx, vars).0 +} + +/// [`resolve`], with the index of the deciding rule in the caller's block, or +/// `None` when the default decided. +pub fn resolve_with_rule( + permissions: &Rules, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> (Action, Option) { + if let Some(rules) = permissions.get(caller) { + for (index, rule) in rules.iter().enumerate() { + if rule.capability == capability + && rule + .filter + .as_ref() + .is_none_or(|f| f.matches_with(ctx, vars)) + { + return (rule.action, Some(index)); + } + } + } + (default_action.into(), None) +} + +/// A resolved decision with the reasoning behind it. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct Resolution { + /// Identical to what [`resolve`] returns for the same inputs. + pub action: Action, + pub cause: ResolutionCause, + /// Rules for the capability, ahead of the deciding rule (or all of them + /// when the default decided), whose filters rejected the call. + pub near_misses: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case", tag = "kind")] +pub enum ResolutionCause { + Rule(RuleRef), + /// No rule matched. `caller_block` is whether the caller has any rules. + Default { + caller_block: bool, + }, +} + +/// A rule located by caller block and zero-based position, with its name when +/// it has one. +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct RuleRef { + pub caller: String, + pub index: usize, + pub name: Option, +} + +/// A rule that named the right capability but whose filter rejected the call. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct NearMiss { + pub rule: RuleRef, + /// The rule's whole filter, from its `Display` impl. + pub filter: String, + pub failures: Vec, +} + +/// [`resolve`], with the reasoning: the deciding rule or default, and the rules +/// for the capability whose filters rejected the call. +pub fn explain( + permissions: &Rules, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> Resolution { + let (action, matched) = + resolve_with_rule(permissions, default_action, caller, capability, ctx, vars); + let rules = permissions.get(caller); + let rule_ref = |index: usize, rule: &PermissionRule| RuleRef { + caller: caller.to_string(), + index, + name: rule.name.clone(), + }; + let cause = match matched.and_then(|index| Some((index, rules?.get(index)?))) { + Some((index, rule)) => ResolutionCause::Rule(rule_ref(index, rule)), + None => ResolutionCause::Default { + caller_block: rules.is_some(), + }, + }; + let walked = matched.unwrap_or(usize::MAX); + let near_misses = rules + .into_iter() + .flatten() + .enumerate() + .take_while(|(index, _)| *index < walked) + .filter(|(_, rule)| rule.capability == capability) + .filter_map(|(index, rule)| { + let filter = rule.filter.as_ref()?; + let evaluation = filter.explain_with(ctx, vars); + (!evaluation.matched).then(|| NearMiss { + rule: rule_ref(index, rule), + filter: filter.to_string(), + failures: evaluation.failures, + }) + }) + .collect(); + Resolution { + action, + cause, + near_misses, + } +} + +#[cfg(test)] +mod tests { + use super::*; + use serde_json::json; + + fn filter(s: &str) -> FilterExpr { + crate::filter::parse(s).expect("valid filter") + } + + /// The shape an embedder that keeps policy outside a blueprint builds: rules + /// whose filters it parsed from its own format, and a default. + #[test] + fn a_policy_built_by_hand_scopes_by_session_variable() { + let policy = Policy { + rules: BTreeMap::from([( + "main".to_string(), + vec![PermissionRule { + name: Some("own tenant".to_string()), + capability: "agent.run".to_string(), + filter: Some("agent == ${vars.agent}".parse().expect("filter")), + action: Action::Allow, + }], + )]), + default: DefaultAction::Deny, + }; + let vars = VarBindings::from([("agent".to_string(), "researcher".to_string())]); + let ctx = |agent: &str| json!({ "agent": agent }); + assert_eq!( + policy.resolve_with_rule("main", "agent.run", &ctx("researcher"), &vars), + (Action::Allow, Some(0)) + ); + assert_eq!( + policy.resolve("main", "agent.run", &ctx("deployer"), &vars), + Action::Deny + ); + let explained = policy.explain("main", "agent.run", &ctx("deployer"), &vars); + assert_eq!(explained.near_misses.len(), 1); + } + + #[test] + fn resolve_first_match_wins() { + let mut perms = BTreeMap::new(); + perms.insert( + "main".to_string(), + vec![ + PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: Some(filter("amount < 500")), + action: Action::Allow, + }, + PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: None, + action: Action::AskHuman, + }, + ], + ); + let allow = resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/charge", + &json!({ "amount": 100 }), + &VarBindings::new(), + ); + assert_eq!(allow, Action::Allow); + let ask = resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/charge", + &json!({ "amount": 900 }), + &VarBindings::new(), + ); + assert_eq!(ask, Action::AskHuman); + } + + #[test] + fn resolve_falls_through_to_default() { + let perms = BTreeMap::new(); + // Caller absent entirely. + assert_eq!( + resolve( + &perms, + DefaultAction::Deny, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::Deny + ); + assert_eq!( + resolve( + &perms, + DefaultAction::AskHuman, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::AskHuman + ); + assert_eq!( + resolve( + &perms, + DefaultAction::Allow, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::Allow + ); + } + + #[test] + fn resolve_capability_is_exact() { + let mut perms = BTreeMap::new(); + perms.insert( + "main".to_string(), + vec![PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: None, + action: Action::Allow, + }], + ); + // No wildcard: a sibling capability falls through to default. + assert_eq!( + resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/refund", + &json!({}), + &VarBindings::new() + ), + Action::Deny + ); + } + + fn rule( + name: Option<&str>, + capability: &str, + f: Option<&str>, + action: Action, + ) -> PermissionRule { + PermissionRule { + name: name.map(str::to_string), + capability: capability.into(), + filter: f.map(filter), + action, + } + } + + fn vars(pairs: &[(&str, &str)]) -> VarBindings { + pairs + .iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect() + } + + fn explain_main( + rules: Vec, + default: DefaultAction, + capability: &str, + ctx: serde_json::Value, + bindings: &VarBindings, + ) -> Resolution { + let perms = BTreeMap::from([("main".to_string(), rules)]); + let resolution = explain(&perms, default, "main", capability, &ctx, bindings); + // The explanation never disagrees with enforcement. + assert_eq!( + resolution.action, + resolve(&perms, default, "main", capability, &ctx, bindings) + ); + resolution + } + + #[test] + fn explain_filter_miss_is_a_near_miss_under_default() { + let resolution = explain_main( + vec![rule( + Some("own-customer"), + "acme.com/charges.list", + Some("customerId == ${vars.customerId}"), + Action::Allow, + )], + DefaultAction::Deny, + "acme.com/charges.list", + json!({ "customerId": "cus_initech" }), + &vars(&[("customerId", "cus_northwind")]), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Default { caller_block: true } + ); + let [miss] = resolution.near_misses.as_slice() else { + panic!("expected one near miss: {resolution:?}"); + }; + assert_eq!(miss.rule.index, 0); + assert_eq!(miss.rule.name.as_deref(), Some("own-customer")); + assert_eq!(miss.filter, "customerId == ${vars.customerId}"); + let [failure] = miss.failures.as_slice() else { + panic!("expected one failure: {miss:?}"); + }; + assert_eq!(failure.comparison, "customerId == ${vars.customerId}"); + assert_eq!(failure.actual, Some(json!("cus_initech"))); + assert_eq!(failure.expected.as_deref(), Some("cus_northwind")); + } + + #[test] + fn explain_second_rule_match_cites_index_and_name() { + let resolution = explain_main( + vec![ + rule( + None, + "stripe.com/charge", + Some("amount < 500"), + Action::Allow, + ), + rule(Some("big-charges"), "stripe.com/charge", None, Action::Deny), + ], + DefaultAction::Allow, + "stripe.com/charge", + json!({ "amount": 900 }), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Rule(RuleRef { + caller: "main".into(), + index: 1, + name: Some("big-charges".into()), + }) + ); + // The earlier rule that rejected the call is still reported. + assert_eq!(resolution.near_misses.len(), 1); + assert_eq!(resolution.near_misses[0].rule.index, 0); + assert_eq!(resolution.near_misses[0].rule.name, None); + } + + #[test] + fn explain_without_caller_block_reports_it() { + let perms = BTreeMap::new(); + let resolution = explain( + &perms, + DefaultAction::Deny, + "main", + "x", + &json!({}), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Default { + caller_block: false + } + ); + assert!(resolution.near_misses.is_empty()); + } + + #[test] + fn explain_ask_human_stays_distinct_and_names_the_rule() { + let resolution = explain_main( + vec![rule( + Some("review-refunds"), + "stripe.com/refund", + None, + Action::AskHuman, + )], + DefaultAction::Deny, + "stripe.com/refund", + json!({}), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::AskHuman); + let ResolutionCause::Rule(rule) = &resolution.cause else { + panic!("expected a rule cause: {resolution:?}"); + }; + assert_eq!(rule.name.as_deref(), Some("review-refunds")); + } + + #[test] + fn explain_unbound_variable_failure() { + let resolution = explain_main( + vec![rule(None, "x", Some("id == ${vars.x}"), Action::Allow)], + DefaultAction::Deny, + "x", + json!({ "id": "a" }), + &VarBindings::new(), + ); + assert_eq!( + resolution.near_misses[0].failures[0].reason, + crate::filter::FailureReason::VariableNotBound("x".into()) + ); + } + + #[test] + fn explain_ignores_other_capabilities() { + let resolution = explain_main( + vec![rule(None, "a", Some("n == 1"), Action::Allow)], + DefaultAction::Deny, + "b", + json!({ "n": 2 }), + &VarBindings::new(), + ); + assert!(resolution.near_misses.is_empty()); + } +} diff --git a/crates/submilli-policy/src/serde_support.rs b/crates/submilli-policy/src/serde_support.rs new file mode 100644 index 000000000..d2bcec792 --- /dev/null +++ b/crates/submilli-policy/src/serde_support.rs @@ -0,0 +1,124 @@ +//! Serde helpers shared by the policy types and the formats that embed them. +//! Not part of the policy API. + +use std::collections::BTreeMap; +use std::fmt; +use std::marker::PhantomData; + +use serde::{Deserialize, Deserializer, de}; + +/// Name-keyed maps must not silently replace an earlier declaration. +pub fn unique_map<'de, D, V>(deserializer: D) -> Result, D::Error> +where + D: Deserializer<'de>, + V: Deserialize<'de>, +{ + deserializer.deserialize_map(UniqueNames(PhantomData)) +} + +struct UniqueNames(PhantomData); + +impl<'de, V: Deserialize<'de>> de::Visitor<'de> for UniqueNames { + type Value = BTreeMap; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map with unique names") + } + + fn visit_map>(self, mut map: A) -> Result { + let mut names = BTreeMap::new(); + while let Some(name) = map.next_key::()? { + if names.contains_key(&name) { + map.next_value_seed(Reject::::new(format!( + "duplicate key `{name}`: remove or rename the repeated declaration" + )))?; + continue; + } + let value = map.next_value()?; + names.insert(name, value); + } + Ok(names) + } +} + +/// A map value whose deserialization always fails, standing in for a value of +/// type `T` so it can replace any field's seed. +/// +/// Raising the error from *inside* the value is what anchors the diagnostic at +/// that key: an error returned from the enclosing map's visitor carries only the +/// map's path, which is too coarse for an editor to squiggle the offending line. +/// Failing from within the visitor rather than after consuming the node also +/// keeps the parser's mark on the value, so the reported line is the offending +/// one and not the first line of the block. +pub struct Reject(String, PhantomData); + +impl Reject { + pub fn new(message: impl Into) -> Self { + Reject(message.into(), PhantomData) + } + + fn fail(self) -> Result { + Err(de::Error::custom(self.0)) + } +} + +impl<'de, T> de::DeserializeSeed<'de> for Reject { + type Value = T; + + fn deserialize(self, deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + deserializer.deserialize_any(self) + } +} + +// Every shape of value gets the same message; the default `Visitor` methods +// would replace it with serde's own `invalid type` wording. +impl<'de, T> de::Visitor<'de> for Reject { + type Value = T; + + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(&self.0) + } + + fn visit_bool(self, _: bool) -> Result { + self.fail() + } + + fn visit_i64(self, _: i64) -> Result { + self.fail() + } + + fn visit_u64(self, _: u64) -> Result { + self.fail() + } + + fn visit_f64(self, _: f64) -> Result { + self.fail() + } + + fn visit_str(self, _: &str) -> Result { + self.fail() + } + + fn visit_bytes(self, _: &[u8]) -> Result { + self.fail() + } + + fn visit_unit(self) -> Result { + self.fail() + } + + fn visit_seq>(self, _: A) -> Result { + self.fail() + } + + fn visit_map>(self, _: A) -> Result { + self.fail() + } + + fn visit_enum>(self, _: A) -> Result { + self.fail() + } +} diff --git a/crates/submilli-policy/src/variables.rs b/crates/submilli-policy/src/variables.rs new file mode 100644 index 000000000..dbb6b973b --- /dev/null +++ b/crates/submilli-policy/src/variables.rs @@ -0,0 +1,86 @@ +//! Session variables: operator-declared, caller-supplied named values bound once +//! per session and referenced as `${vars.NAME}` in permission filters. Unlike a +//! secret (whose value the program never sees, injected only into outbound +//! auth), a variable *is* the value, matched against in a filter to scope a +//! capability to per-session data (e.g. a tenant id). + +use std::collections::BTreeMap; +use std::fmt; + +use serde::{Deserialize, Serialize}; + +/// One declared variable. `required` and `default` are mutually exclusive: a +/// required variable with a default is contradictory (rejected at parse). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct VariableDecl { + /// The session is rejected at init if this variable is missing or empty. + #[serde(default, skip_serializing_if = "is_false")] + pub required: bool, + /// Value bound when the caller supplies none. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default: Option, +} + +fn is_false(b: &bool) -> bool { + !*b +} + +/// A failure binding caller-supplied variables against the blueprint's +/// declarations, surfaced at session init (REST → 400, MCP → failed +/// `initialize`). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum VariableError { + /// A `required` variable was not supplied (or supplied empty). + MissingRequired(String), + /// A supplied variable name is not declared in the blueprint. + Unknown(String), +} + +impl fmt::Display for VariableError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + VariableError::MissingRequired(name) => { + write!(f, "required variable '{name}' was not supplied") + } + VariableError::Unknown(name) => { + write!(f, "variable '{name}' is not declared in the blueprint") + } + } + } +} + +impl std::error::Error for VariableError {} + +/// Bind caller-supplied values against the declarations: fill defaults, reject a +/// missing/empty `required` variable, reject any supplied name that isn't +/// declared. Returns the resolved bindings filter evaluation reads. An optional +/// variable with no value and no default is simply omitted — an absent +/// `${vars.NAME}` is a non-match at eval, never a trap. +pub fn resolve_variables( + decls: &BTreeMap, + supplied: &BTreeMap, +) -> Result, VariableError> { + for name in supplied.keys() { + if !decls.contains_key(name) { + return Err(VariableError::Unknown(name.clone())); + } + } + let mut resolved = BTreeMap::new(); + for (name, decl) in decls { + match supplied.get(name) { + Some(value) if !value.is_empty() => { + resolved.insert(name.clone(), value.clone()); + } + _ => { + if decl.required { + return Err(VariableError::MissingRequired(name.clone())); + } + if let Some(default) = &decl.default { + resolved.insert(name.clone(), default.clone()); + } + } + } + } + Ok(resolved) +} diff --git a/crates/submilli-policy/tests/engine_literal_parity.rs b/crates/submilli-policy/tests/engine_literal_parity.rs new file mode 100644 index 000000000..5540b3842 --- /dev/null +++ b/crates/submilli-policy/tests/engine_literal_parity.rs @@ -0,0 +1,68 @@ +//! The engine writes filters into a package's derived requirements without +//! depending on this crate, so its quoting is a second copy of +//! [`quote_literal`]. These tests keep the two in step, and check that every +//! field name the engine's capability catalog offers can be written in a +//! filter. + +use interpreter::capability_derivation::filter_string_literal; +use interpreter::stdlib::capabilities; +use interpreter::{OptionalPackage, Stdlib}; +use submilli_policy::filter_syntax::{is_field_name, parse, quote_literal}; + +const CORPUS: &[&str] = &[ + "", + "plain", + "with \"quotes\"", + "back\\slash", + "line\nbreak", + "tab\tand\rreturn", + "${vars.x}", + "prefix ${vars.tenant} suffix", + "${other}", + "$", + "{", + "}", + "${", + "${vars", + "naïve — ünïcödé ✓", + "/repos/acme/*", +]; + +#[test] +fn the_engine_quotes_every_value_as_the_policy_does() { + for value in CORPUS { + assert_eq!( + filter_string_literal(value), + quote_literal(value), + "{value:?}" + ); + } +} + +#[test] +fn a_quoted_value_reads_back_as_itself() { + for value in CORPUS { + let Some(literal) = filter_string_literal(value) else { + continue; + }; + let filter = parse(&format!("f == {literal}")).expect("parses"); + assert!( + filter.matches(&serde_json::json!({ "f": value })), + "{value:?} as {literal}" + ); + } +} + +#[test] +fn every_cataloged_field_can_be_written_in_a_filter() { + let every = Stdlib::core() + .with(OptionalPackage::Agents) + .with(OptionalPackage::Skills); + for group in capabilities::catalog_for(every) { + for capability in group.capabilities { + for field in capability.field_names() { + assert!(is_field_name(field), "{}: {field}", capability.name); + } + } + } +} diff --git a/crates/submilli-server/src/handlers/execute.rs b/crates/submilli-server/src/handlers/execute.rs index 56298fcd6..d3668d449 100644 --- a/crates/submilli-server/src/handlers/execute.rs +++ b/crates/submilli-server/src/handlers/execute.rs @@ -569,7 +569,7 @@ async fn prepare_and_run( }; let manager = state.session_manager(); let policy: Arc = Arc::new( - PolicyCheck::with_variables(Arc::clone(&blueprint), Arc::clone(&variables)), + PolicyCheck::with_variables(Arc::new(blueprint.policy()), Arc::clone(&variables)), ); let security_check = execution_audit.as_ref().map_or_else( || policy.clone(), diff --git a/crates/submilli-server/src/mcp/server.rs b/crates/submilli-server/src/mcp/server.rs index 4b9125839..62e64a3ec 100644 --- a/crates/submilli-server/src/mcp/server.rs +++ b/crates/submilli-server/src/mcp/server.rs @@ -761,8 +761,10 @@ impl SubmilliMcp { .map_err(|error| FileToolError::file(path, error.into()))?; let recording = self.file_tool_recording(parts, &blueprint, &variables, tool.name); let log = recording.as_ref().map(crate::record::Recording::log); - let policy: Arc = - Arc::new(PolicyCheck::with_variables(blueprint.clone(), variables)); + let policy: Arc = Arc::new(PolicyCheck::with_variables( + Arc::new(blueprint.policy()), + variables, + )); let policy = log.as_ref().map_or(policy.clone(), |log| log.wrap(policy)); let call = policy.recorder().map(|recorder| { let marker = recorder.enter_host_call(); diff --git a/crates/submilli-server/tests/decision_records_policy.rs b/crates/submilli-server/tests/decision_records_policy.rs index 60de610e9..6a49dbced 100644 --- a/crates/submilli-server/tests/decision_records_policy.rs +++ b/crates/submilli-server/tests/decision_records_policy.rs @@ -25,7 +25,7 @@ async fn a_recorded_run_cites_an_unnormalizable_path_as_a_runtime_invariant() { data.install_type_info(script.type_info.clone()); // Under `default: allow`, only the path keeps this call from being allowed. data.security_check = Arc::new(PolicyCheck::new(Arc::new( - parse("name: open\ndefault: allow\n").unwrap(), + parse("name: open\ndefault: allow\n").unwrap().policy(), ))); let log = DecisionLog::install(&mut data, DecisionLogConfig::default()); let mut store = cfg.store_async(&engine, data).unwrap(); diff --git a/crates/submilli-server/tests/replay.rs b/crates/submilli-server/tests/replay.rs index 1b5c6d639..a9a77acb3 100644 --- a/crates/submilli-server/tests/replay.rs +++ b/crates/submilli-server/tests/replay.rs @@ -312,7 +312,7 @@ async fn run(source: &str, setup: Setup) -> Outcome { None, Arc::new(setup.secrets), )); - data.security_check = Arc::new(PolicyCheck::new(blueprint)); + data.security_check = Arc::new(PolicyCheck::new(Arc::new(blueprint.policy()))); if let Some(llm) = setup.llm { data.llm_provider = Some(llm); } diff --git a/crates/submilli-shared/Cargo.toml b/crates/submilli-shared/Cargo.toml index 30fbb19ef..a1f84de7a 100644 --- a/crates/submilli-shared/Cargo.toml +++ b/crates/submilli-shared/Cargo.toml @@ -15,6 +15,7 @@ path = "src/lib.rs" [dependencies] interpreter = { path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } +submilli-policy = { path = "../submilli-policy", features = ["engine"] } submilli-build = { path = "../submilli-build" } anyhow = { workspace = true } sha2 = "0.10" diff --git a/crates/submilli-shared/src/host.rs b/crates/submilli-shared/src/host.rs index a843c473e..f5a0ab91a 100644 --- a/crates/submilli-shared/src/host.rs +++ b/crates/submilli-shared/src/host.rs @@ -1,254 +1,20 @@ -//! Embedder glue that adapts a [`Blueprint`] to the runtime's host-service -//! traits ([`SecurityCheck`], [`AuthProxy`], [`SecretProvider`]). The policy -//! logic, filter matching, and `${secrets.X}` interpolation live in -//! `submilli-blueprint`; this is the thin `interpreter`-facing layer that an -//! embedder (the server, or local-dev `submilli run --blueprint`) installs onto -//! a `StoreData`. It lives here rather than in `submilli-blueprint` so that -//! crate stays free of the `interpreter` dependency. +//! Embedder glue that wires a [`Blueprint`] into the runtime's host-service +//! traits ([`AuthProxy`], [`SecretProvider`], and `SecurityCheck` through +//! [`PolicyCheck`]). The adapters themselves live in `submilli-policy`; this +//! ties them to the blueprint's `secrets:` block and the server's secret store. -use std::borrow::Cow; use std::sync::Arc; use async_trait::async_trait; -use interpreter::runtime::{ - AuthProxy, AuthProxyError, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, - FailureReasonRecord, FailureRecord, HttpRequest, NearMissRecord, RuleCitation, SecretProvider, - SecurityCheck, -}; -use interpreter::stdlib::http::HttpTransportPolicy; -use url::Url; - -use std::collections::BTreeMap; - +use interpreter::runtime::{AuthProxy, AuthProxyError, HttpRequest, SecretProvider}; use submilli_blueprint::{ - Action, AuthError, Blueprint, ComparisonFailure, FailureReason, HarnessSecretBindings, - Injections, NearMiss, Resolution, ResolutionCause, RuleRef, SecretResolver, SecretSource, - VarBindings, resolve_injections, + AuthError, Blueprint, DeclaredSecrets, HarnessSecretBindings, SecretSource, + SourceSecretResolver, }; +use submilli_policy::SecretResolver; +use submilli_policy::host::{PolicyAuthProxy, PolicySecretProvider}; -/// The package name auth-proxy injection is scoped to. Matches the name the runtime gives a -/// user script's module, which is what it reads off the running wasm frame to identify a -/// caller. -const MAIN_PACKAGE: &str = "main"; - -// ---- SecurityCheck ------------------------------------------------------- - -/// Blueprint-driven [`SecurityCheck`]: evaluates the blueprint's `permissions:` -/// rules for each capability check. -/// -/// Deny-by-default: a capability is allowed only when a rule says so, and a -/// policy-free blueprint (no `permissions:`, no `default:`) denies every -/// capability. `default: allow` inverts this to allow-by-default. `ask-human` -/// is deferred (no suspend/resume yet), so it resolves to `Deny` with a reason -/// that says so. -/// -/// Filesystem rules see absolute guest paths with `.` and `..` collapsed using -/// the same lexical resolver as VFS I/O. This also applies to both endpoints of -/// copy/move and the destination of HTTP downloads. It does not resolve symlinks. -pub struct PolicyCheck { - blueprint: Arc, - /// Caller-supplied `${vars.NAME}` bindings for this session, resolved at - /// session init. Empty for callers that bind no variables. - variables: Arc, -} - -impl PolicyCheck { - pub fn new(blueprint: Arc) -> Self { - Self::with_variables(blueprint, Arc::new(BTreeMap::new())) - } - - /// As [`Self::new`], with the session's resolved variable bindings threaded - /// into every `${vars.NAME}` filter operand. - pub fn with_variables(blueprint: Arc, variables: Arc) -> Self { - PolicyCheck { - blueprint, - variables, - } - } -} - -impl SecurityCheck for PolicyCheck { - fn audit_context<'a>( - &self, - capability: &str, - context: &'a serde_json::Value, - cwd: &str, - ) -> Cow<'a, serde_json::Value> { - filesystem_policy_context(capability, context, cwd).unwrap_or(Cow::Borrowed(context)) - } - - fn check(&self, caller: &str, capability: &str, context: &serde_json::Value) -> CheckOutcome { - self.check_with_cwd(caller, capability, context, "/") - } - - fn explain( - &self, - caller: &str, - capability: &str, - context: &serde_json::Value, - cwd: &str, - ) -> Option { - let context = match filesystem_policy_context(capability, context, cwd) { - Ok(context) => context, - // `check_with_cwd` refuses these before resolution: no rule can grant them. - Err(reason) => { - return Some(DecisionExplanation { - action: DecisionAction::Deny, - cause: DecisionCause::RuntimeInvariant { reason }, - near_misses: Vec::new(), - }); - } - }; - let resolution = - self.blueprint - .explain_permission(caller, capability, &context, &self.variables); - Some(explanation_of(resolution)) - } - - fn check_with_cwd( - &self, - caller: &str, - capability: &str, - context: &serde_json::Value, - cwd: &str, - ) -> CheckOutcome { - let context = match filesystem_policy_context(capability, context, cwd) { - Ok(context) => context, - Err(reason) => return CheckOutcome::Deny { reason, rule: None }, - }; - let (action, rule) = self.blueprint.resolve_permission_with_rule( - caller, - capability, - &context, - &self.variables, - ); - match action { - Action::Allow => CheckOutcome::Allow { rule }, - Action::Deny => CheckOutcome::Deny { - rule, - reason: format!( - "policy denied {capability}{} for {caller}", - filesystem_target(capability, &context) - ), - }, - Action::AskHuman => CheckOutcome::Deny { - rule, - reason: format!( - "policy requires human approval for {capability}{} (caller {caller}); \ - ask-human is deferred and treated as deny", - filesystem_target(capability, &context) - ), - }, - } - } -} - -fn explanation_of(resolution: Resolution) -> DecisionExplanation { - DecisionExplanation { - action: match resolution.action { - Action::Allow => DecisionAction::Allow, - Action::Deny => DecisionAction::Deny, - Action::AskHuman => DecisionAction::AskHuman, - }, - cause: cause_of(resolution.cause), - near_misses: resolution - .near_misses - .into_iter() - .map(near_miss_record) - .collect(), - } -} - -fn citation(rule: RuleRef) -> RuleCitation { - RuleCitation { - caller: rule.caller, - index: rule.index, - name: rule.name, - } -} - -fn cause_of(cause: ResolutionCause) -> DecisionCause { - match cause { - ResolutionCause::Rule(rule) => DecisionCause::Rule(citation(rule)), - ResolutionCause::Default { caller_block } => DecisionCause::Default { caller_block }, - } -} - -fn near_miss_record(miss: NearMiss) -> NearMissRecord { - NearMissRecord { - rule: citation(miss.rule), - filter: miss.filter, - failures: miss.failures.into_iter().map(failure_record).collect(), - } -} - -fn failure_record(failure: ComparisonFailure) -> FailureRecord { - let reason = match failure.reason { - FailureReason::FieldMissing => FailureReasonRecord::FieldMissing, - FailureReason::VariableNotBound(name) => FailureReasonRecord::VariableNotBound(name), - FailureReason::NotSatisfied => FailureReasonRecord::NotSatisfied, - }; - FailureRecord { - comparison: failure.comparison, - actual: failure.actual, - expected: failure.expected, - reason, - negated: failure.negated, - } -} - -/// The normalized VFS paths a denial was for, so a narrowed filter can be fixed -/// from the message. The library may have probed a path on the program's -/// behalf, as `submilli:code` does for ignore files, so the program's own -/// arguments do not always name it. Empty for capabilities without VFS paths. -fn filesystem_target(capability: &str, context: &serde_json::Value) -> String { - let path = |field: &&str| context.get(*field).and_then(serde_json::Value::as_str); - match filesystem_path_fields(capability) { - [single] => path(single).map_or_else(String::new, |path| format!(" on {path}")), - [from, to] => match (path(from), path(to)) { - (Some(from), Some(to)) => format!(" from {from} to {to}"), - _ => String::new(), - }, - _ => String::new(), - } -} - -/// The context fields of a capability that hold VFS paths. -fn filesystem_path_fields(capability: &str) -> &'static [&'static str] { - match capability { - "fs.read" | "fs.write" | "fs.stat" | "fs.list" | "fs.mkdir" | "fs.remove" => &["path"], - "fs.copy" | "fs.move" => &["from", "to"], - "git.init" | "git.clone" | "git.fetch" | "git.commit" => &["path"], - "http.download" => &["vfs_path"], - _ => &[], - } -} - -/// Keep policy paths in the same guest namespace as the subsequent VFS operation. -/// Normalization is lexical and performs no I/O, so a denial cannot reveal whether -/// the target exists. URL paths and application-defined capabilities stay untouched. -fn filesystem_policy_context<'a>( - capability: &str, - context: &'a serde_json::Value, - cwd: &str, -) -> Result, String> { - let fields = filesystem_path_fields(capability); - let mut normalized_context = Cow::Borrowed(context); - for &field in fields { - let path = context - .get(field) - .and_then(serde_json::Value::as_str) - .ok_or_else(|| { - format!("invalid {capability} context: {field} must be a VFS path string") - })?; - let normalized = interpreter::runtime::fs::guest_normalize(cwd, path) - .map_err(|error| format!("invalid {capability} {field}: {error}"))?; - if normalized != path { - normalized_context.to_mut()[field] = serde_json::Value::String(normalized); - } - } - Ok(normalized_context) -} +pub use submilli_policy::host::PolicyCheck; // ---- SecretStore --------------------------------------------------------- @@ -308,7 +74,7 @@ impl BlueprintSecretResolver { } #[async_trait] -impl SecretResolver for BlueprintSecretResolver { +impl SourceSecretResolver for BlueprintSecretResolver { async fn resolve(&self, name: &str, source: &SecretSource) -> Result { match source { // On-demand decrypt: reads + opens the one sealed file, awaited so the @@ -334,12 +100,38 @@ impl SecretResolver for BlueprintSecretResolver { } } -/// Blueprint-backed provider for script-visible `submilli:secrets.get`. -pub struct BlueprintSecretProvider { +/// A blueprint's declared secrets as a policy [`SecretResolver`]: a name the +/// `secrets:` block does not declare is undeclared, and a declared one resolves +/// from its source. +pub struct BlueprintSecrets { blueprint: Arc, resolver: BlueprintSecretResolver, } +impl BlueprintSecrets { + pub fn new(blueprint: Arc, resolver: BlueprintSecretResolver) -> Self { + Self { + blueprint, + resolver, + } + } +} + +#[async_trait] +impl SecretResolver for BlueprintSecrets { + async fn resolve(&self, name: &str) -> Result { + DeclaredSecrets { + blueprint: &self.blueprint, + inner: &self.resolver, + } + .resolve(name) + .await + } +} + +/// Blueprint-backed provider for script-visible `submilli:secrets.get`. +pub struct BlueprintSecretProvider(PolicySecretProvider); + impl BlueprintSecretProvider { pub fn new(blueprint: Arc, store: Option>) -> Self { Self::with_harness(blueprint, store, Arc::new(HarnessSecretBindings::new())) @@ -350,10 +142,11 @@ impl BlueprintSecretProvider { store: Option>, harness: Arc, ) -> Self { - Self { + let secrets = BlueprintSecrets::new( blueprint, - resolver: BlueprintSecretResolver::with_harness(store, harness), - } + BlueprintSecretResolver::with_harness(store, harness), + ); + Self(PolicySecretProvider::new(Arc::new(secrets))) } } @@ -364,16 +157,7 @@ impl SecretProvider for BlueprintSecretProvider { ) -> std::pin::Pin< Box, String>> + Send + 'a>, > { - Box::pin(async move { - let Some(source) = self.blueprint.secrets.get(name) else { - return Ok(None); - }; - match self.resolver.resolve(name, source).await { - Ok(value) => Ok(Some(value)), - Err(AuthError::UndeclaredSecret(_) | AuthError::MissingSecret(_)) => Ok(None), - Err(AuthError::Other(msg)) => Err(msg), - } - }) + self.0.get(name) } } @@ -382,12 +166,7 @@ impl SecretProvider for BlueprintSecretProvider { /// [`AuthProxy`] backed by a blueprint's `auth_proxy:` + `secrets:` blocks. /// Injects the matching rule's headers / query params (with `${secrets.X}` /// resolved) into outbound `submilli:http` calls made by `main`. -pub struct BlueprintAuthProxy { - transport_policy: Arc, - authenticated_policy: Arc, - blueprint: Arc, - resolver: BlueprintSecretResolver, -} +pub struct BlueprintAuthProxy(PolicyAuthProxy); impl BlueprintAuthProxy { pub fn new(blueprint: Arc, store: Option>) -> Self { @@ -399,25 +178,12 @@ impl BlueprintAuthProxy { store: Option>, harness: Arc, ) -> Self { - let transport_policy = HttpTransportPolicy { - allow_insecure_http: blueprint.allow_insecure_http, - auth_proxy_hosts: blueprint - .auth_proxy - .iter() - .map(|rule| (rule.host.clone(), rule.allow_insecure_http)) - .collect(), - same_origin_redirects: false, - }; - let authenticated_policy = Arc::new(HttpTransportPolicy { - same_origin_redirects: true, - ..transport_policy.clone() - }); - Self { - transport_policy: Arc::new(transport_policy), - authenticated_policy, + let policy = blueprint.auth_proxy_policy(); + let secrets = BlueprintSecrets::new( blueprint, - resolver: BlueprintSecretResolver::with_harness(store, harness), - } + BlueprintSecretResolver::with_harness(store, harness), + ); + Self(PolicyAuthProxy::new(policy, Arc::new(secrets))) } } @@ -425,94 +191,36 @@ impl BlueprintAuthProxy { impl AuthProxy for BlueprintAuthProxy { async fn transform( &self, - mut req: HttpRequest, + req: HttpRequest, caller: &str, ) -> Result { - req.transport_policy = Some(Arc::clone(&self.transport_policy)); - // Check every caller before resolving credentials, including package calls. - let url = - Url::parse(&req.url).map_err(|_| AuthProxyError::Other("invalid HTTP URL".into()))?; - self.transport_policy - .check_destination(&url) - .map_err(|error| AuthProxyError::Other(error.to_string()))?; - if caller != MAIN_PACKAGE { - return Ok(req); - } - let Some(host) = url.host_str() else { - return Ok(req); - }; - let Some(injections) = resolve_injections(&self.blueprint, host, &self.resolver) - .await - .map_err(to_proxy_error)? - else { - return Ok(req); - }; - req.transport_policy = Some(Arc::clone(&self.authenticated_policy)); - apply(&mut req, injections); - Ok(req) - } -} - -/// Apply injections; the blueprint value overrides any the script set itself. -fn apply(req: &mut HttpRequest, injections: Injections) { - for (name, value) in injections.headers { - let key = name.to_ascii_lowercase(); // host stores header names lowercased - req.headers.retain(|(k, _)| *k != key); - req.headers.push((key, value)); - } - if !injections.query.is_empty() - && let Ok(url) = Url::parse(&req.url) - { - req.url = with_query(&url, &injections.query); - } -} - -/// Rebuild the URL's query string: keep the script's params except those the -/// blueprint sets (blueprint wins), then append the injected ones. -fn with_query(url: &Url, injected: &[(String, String)]) -> String { - let overridden: Vec<&str> = injected.iter().map(|(k, _)| k.as_str()).collect(); - let kept: Vec<(String, String)> = url - .query_pairs() - .filter(|(k, _)| !overridden.contains(&k.as_ref())) - .map(|(k, v)| (k.into_owned(), v.into_owned())) - .collect(); - let mut out = url.clone(); - { - let mut pairs = out.query_pairs_mut(); - pairs.clear(); - for (k, v) in &kept { - pairs.append_pair(k, v); - } - for (k, v) in injected { - pairs.append_pair(k, v); - } - } - // `query_pairs_mut().clear()` on an originally-empty query leaves a bare `?`. - if out.query() == Some("") { - out.set_query(None); - } - out.to_string() -} - -fn to_proxy_error(err: AuthError) -> AuthProxyError { - match err { - AuthError::UndeclaredSecret(name) => AuthProxyError::UndeclaredSecret(name), - AuthError::MissingSecret(name) => AuthProxyError::MissingSecret(name), - AuthError::Other(msg) => AuthProxyError::Other(msg), + self.0.transform(req, caller).await } } #[cfg(test)] mod tests { + use std::collections::BTreeMap; + + use interpreter::runtime::{ + CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, FailureReasonRecord, + RuleCitation, SecurityCheck, + }; + use submilli_blueprint::{Policy, parse}; + use url::Url; + use super::*; - use submilli_blueprint::parse; + + fn policy_of(blueprint: Blueprint) -> Arc { + Arc::new(blueprint.policy()) + } /// Call-site derivation normalizes the same fields from the catalog, so a /// derived `requires` filter names the path this check sees. #[test] fn working_directory_is_used_for_all_filesystem_policy_fields() { let blueprint = parse("name: cwd\ndefault: deny\npermissions:\n main:\n - {capability: fs.read, action: allow, filter: 'path glob \"/notes/*\"'}\n - {capability: fs.move, action: allow, filter: 'from glob \"/notes/*\" and to glob \"/notes/*\"'}\n - {capability: http.download, action: allow, filter: 'vfs_path glob \"/notes/*\"'}\n").unwrap(); - let policy = PolicyCheck::new(Arc::new(blueprint)); + let policy = PolicyCheck::new(policy_of(blueprint)); for (capability, context) in [ ("fs.read", serde_json::json!({"path":"a"})), ("fs.move", serde_json::json!({"from":"a", "to":"b"})), @@ -539,7 +247,7 @@ mod tests { } fn explained_blueprint() -> PolicyCheck { - PolicyCheck::new(Arc::new( + PolicyCheck::new(policy_of( parse( r#" name: explained @@ -648,7 +356,7 @@ permissions: #[test] fn a_path_that_cannot_be_normalized_is_a_runtime_invariant_with_its_reason() { - let policy = PolicyCheck::new(Arc::new(parse("name: open\ndefault: allow\n").unwrap())); + let policy = PolicyCheck::new(policy_of(parse("name: open\ndefault: allow\n").unwrap())); let context = serde_json::json!({"path": "/a\u{0}b"}); // Enforcement is what it was: a denial with no rule, which reads as a default deny // to the server's audit and keeps doing so. @@ -678,26 +386,6 @@ permissions: )); } - #[test] - fn normalized_policy_paths_are_vfs_path_fields_in_the_catalog() { - use interpreter::stdlib::capabilities::{FieldNormalization, catalog}; - for capability in catalog().iter().flat_map(|group| group.capabilities) { - for field in filesystem_path_fields(capability.name) { - let normalization = capability - .filter_fields - .iter() - .find(|candidate| candidate.name == *field) - .map(|candidate| candidate.normalization); - assert_eq!( - normalization, - Some(FieldNormalization::VfsPath), - "{}.{field}", - capability.name - ); - } - } - } - #[test] fn filesystem_policy_matches_normalized_guest_paths() { let blueprint = parse( @@ -738,7 +426,7 @@ permissions: ) .unwrap(); let policy = PolicyCheck::with_variables( - Arc::new(blueprint), + policy_of(blueprint), Arc::new(BTreeMap::from([("user".into(), "ada".into())])), ); for capability in [ @@ -821,7 +509,7 @@ permissions: #[test] fn filesystem_denials_name_the_normalized_path() { - let policy = PolicyCheck::new(Arc::new( + let policy = PolicyCheck::new(policy_of( parse( r#" name: closed @@ -867,7 +555,7 @@ permissions: #[test] fn filesystem_policy_blocklists_use_the_resolved_path() { - let policy = PolicyCheck::new(Arc::new( + let policy = PolicyCheck::new(policy_of( parse( r#" name: blocked diff --git a/crates/submilli/src/commands/run.rs b/crates/submilli/src/commands/run.rs index a72f0f75d..30fbde746 100644 --- a/crates/submilli/src/commands/run.rs +++ b/crates/submilli/src/commands/run.rs @@ -501,7 +501,10 @@ fn execute_on_this_thread( data.install_type_info(compiled.type_info.clone()); if let Some(bp) = &blueprint { data.git = submilli_shared::resolve_git(bp, &variables)?; - data.security_check = Arc::new(PolicyCheck::with_variables(bp.clone(), variables)); + data.security_check = Arc::new(PolicyCheck::with_variables( + Arc::new(bp.policy()), + variables, + )); data.auth_proxy = Arc::new(BlueprintAuthProxy::new(bp.clone(), secret_store.clone())); data.secret_provider = Arc::new(BlueprintSecretProvider::new( bp.clone(), From c50ba2424ad78f20ad4b934c49cc69823550c5c2 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 17:58:10 +0300 Subject: [PATCH 05/10] Rename the engine to submilli-engine and prepare both crates for crates.io The interpreter crate compiles and runs programs, and its name was taken on crates.io; it is now submilli-engine. Dependents keep their `interpreter` key through `package = "submilli-engine"`, so their sources are unchanged; the engine's own tests, unit-test snapshot names, CI and the release skill use the new name. The directory stays crates/interpreter. submilli-engine and submilli-policy now publish, with descriptions and READMEs. The engine's package leaves out its tests and snapshots (2 MiB compressed). CI packages both with a publish dry run. Co-Authored-By: Claude Opus 5.5 --- .agents/skills/release/SKILL.md | 8 +- .github/workflows/ci.yml | 12 +- .github/workflows/conformance.yml | 8 +- AGENTS.md | 4 +- Cargo.lock | 114 +++++++++--------- crates/conformance/Cargo.toml | 2 +- crates/interpreter/Cargo.toml | 10 +- crates/interpreter/README.md | 14 +++ ...__assert_false_throws_with_backtrace.snap} | 0 ...sor_and_constructor_frames_are_named.snap} | 0 ..._a_cast_keeps_its_backtrace_location.snap} | 0 ...__codegen__tests__dwarf_die_snapshot.snap} | 0 ...ts__dwarf_line_program_covers_helper.snap} | 0 ...__tests__dwarf_line_program_snapshot.snap} | 0 ...f_subprograms_for_each_user_function.snap} | 0 ...ed_cast_backtrace_points_at_the_cast.snap} | 0 ...odegen__tests__multi_frame_backtrace.snap} | 0 ...me_backtrace_labels_caller_in_middle.snap} | 0 ...ne__asi__tests__mvp_fixture_snapshot.snap} | 0 ...nostics__tests__render_clamps_at_eof.snap} | 0 ...nostics__tests__render_clamps_at_sof.snap} | 0 ...lti_note_error_with_gutter_alignment.snap} | 0 ..._tests__render_multiline_span_carets.snap} | 0 ...ostics__tests__render_multiple_helps.snap} | 0 ...ics__tests__render_single_line_error.snap} | 0 ...tics__tests__render_warning_severity.snap} | 0 ...diagnostics__tests__render_with_help.snap} | 0 ...s__tests__render_with_help_and_notes.snap} | 0 ...ests__render_zero_length_span_at_eof.snap} | 0 ...ts__renders_bare_exponent_diagnostic.snap} | 0 ...nders_unterminated_string_diagnostic.snap} | 0 ...ers_unterminated_template_diagnostic.snap} | 0 ...__lexer__tests__tokenize_mvp_fixture.snap} | 0 ...ests__full_precedence_chain_snapshot.snap} | 0 ...rser__tests__parse_sequence_of_atoms.snap} | 0 ...arser__tests__snapshot_else_if_chain.snap} | 0 ...tests__snapshot_function_declaration.snap} | 0 ...snapshot_function_with_if_and_return.snap} | 0 ..._tests__snapshot_function_with_while.snap} | 0 ...__tests__snapshot_mixed_declarations.snap} | 0 ...__tests__snapshot_multi_call_program.snap} | 0 ...__tests__snapshot_multi_error_render.snap} | 0 ...__snapshot_object_and_array_literals.snap} | 0 ...rser__tests__snapshot_union_type_mix.snap} | 0 ..._expr__tests__snapshot_mixed_program.snap} | 0 ..._array_substitutes_interface_generic.snap} | 0 ...__tests__function_renders_arrow_form.snap} | 0 ...erface_ref_substitutes_multiple_args.snap} | 0 ..._interface_renders_optional_property.snap} | 0 ..._tests__interface_renders_properties.snap} | 0 ...terface_substitutes_property_generic.snap} | 0 ...sts__object_renders_structural_shape.snap} | 0 ...sts__primitive_with_declared_methods.snap} | 0 ...ype_diff__tests__function_arity_diff.snap} | 0 ...function_combined_arity_param_return.snap} | 0 ...iff__tests__function_param_type_diff.snap} | 0 ...ff__tests__function_return_type_diff.snap} | 0 ...__tests__object_all_three_dimensions.snap} | 0 ...type_diff__tests__object_extra_field.snap} | 0 ...f__tests__object_field_type_mismatch.snap} | 0 ...pe_diff__tests__object_missing_field.snap} | 0 crates/interpreter/tests/checked_arena.rs | 2 +- crates/interpreter/tests/checked_rendering.rs | 23 ++-- crates/interpreter/tests/checked_source.rs | 51 ++++---- .../interpreter/tests/checked_typed_phases.rs | 69 ++++++----- .../tests/checked_untyped_phases.rs | 50 ++++---- crates/interpreter/tests/class_rec_group.rs | 2 +- crates/interpreter/tests/closure_arity.rs | 6 +- .../tests/closure_arity_diagnostics.rs | 32 ++--- .../tests/closure_lowering_errors.rs | 8 +- .../tests/compiler_structure_limits.rs | 6 +- crates/interpreter/tests/console_failure.rs | 8 +- .../tests/cross_module_gc_types.rs | 2 +- crates/interpreter/tests/decision_records.rs | 32 ++--- crates/interpreter/tests/determinism.rs | 4 +- .../interpreter/tests/diagnostic_snapshots.rs | 4 +- crates/interpreter/tests/field_lookup_size.rs | 2 +- crates/interpreter/tests/fixtures.rs | 57 ++++----- crates/interpreter/tests/git_memory.rs | 12 +- crates/interpreter/tests/host_memory.rs | 16 ++- crates/interpreter/tests/http_live.rs | 4 +- crates/interpreter/tests/lexer_limits.rs | 4 +- crates/interpreter/tests/memory_caps.rs | 22 ++-- crates/interpreter/tests/namespace_limits.rs | 22 ++-- .../tests/object_vtable_dispatch.rs | 2 +- .../tests/package_diagnostic_snapshots.rs | 9 +- crates/interpreter/tests/parser_depth.rs | 2 +- crates/interpreter/tests/record_limits.rs | 8 +- .../interpreter/tests/substitution_limits.rs | 6 +- .../interpreter/tests/traps_in_callbacks.rs | 6 +- crates/interpreter/tests/type_limits.rs | 30 ++--- crates/interpreter/tests/vfs_containment.rs | 4 +- crates/submilli-build/Cargo.toml | 2 +- crates/submilli-policy/Cargo.toml | 12 +- crates/submilli-policy/README.md | 15 +++ crates/submilli-policy/src/host.rs | 8 +- .../tests/engine_literal_parity.rs | 6 +- crates/submilli-server/Cargo.toml | 2 +- crates/submilli-shared/Cargo.toml | 2 +- crates/submilli/Cargo.toml | 2 +- 100 files changed, 403 insertions(+), 323 deletions(-) create mode 100644 crates/interpreter/README.md rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__assert_false_throws_with_backtrace.snap => submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap => submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap => submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__dwarf_die_snapshot.snap => submilli_engine__codegen__tests__dwarf_die_snapshot.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__dwarf_line_program_covers_helper.snap => submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__dwarf_line_program_snapshot.snap => submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__dwarf_subprograms_for_each_user_function.snap => submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap => submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__multi_frame_backtrace.snap => submilli_engine__codegen__tests__multi_frame_backtrace.snap} (100%) rename crates/interpreter/src/codegen/snapshots/{interpreter__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap => submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__asi__tests__mvp_fixture_snapshot.snap => submilli_engine__asi__tests__mvp_fixture_snapshot.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_clamps_at_eof.snap => submilli_engine__diagnostics__tests__render_clamps_at_eof.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_clamps_at_sof.snap => submilli_engine__diagnostics__tests__render_clamps_at_sof.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap => submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_multiline_span_carets.snap => submilli_engine__diagnostics__tests__render_multiline_span_carets.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_multiple_helps.snap => submilli_engine__diagnostics__tests__render_multiple_helps.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_single_line_error.snap => submilli_engine__diagnostics__tests__render_single_line_error.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_warning_severity.snap => submilli_engine__diagnostics__tests__render_warning_severity.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_with_help.snap => submilli_engine__diagnostics__tests__render_with_help.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_with_help_and_notes.snap => submilli_engine__diagnostics__tests__render_with_help_and_notes.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__diagnostics__tests__render_zero_length_span_at_eof.snap => submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__lexer__tests__renders_bare_exponent_diagnostic.snap => submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__lexer__tests__renders_unterminated_string_diagnostic.snap => submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__lexer__tests__renders_unterminated_template_diagnostic.snap => submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__lexer__tests__tokenize_mvp_fixture.snap => submilli_engine__lexer__tests__tokenize_mvp_fixture.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__full_precedence_chain_snapshot.snap => submilli_engine__parser__tests__full_precedence_chain_snapshot.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__parse_sequence_of_atoms.snap => submilli_engine__parser__tests__parse_sequence_of_atoms.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_else_if_chain.snap => submilli_engine__parser__tests__snapshot_else_if_chain.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_function_declaration.snap => submilli_engine__parser__tests__snapshot_function_declaration.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_function_with_if_and_return.snap => submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_function_with_while.snap => submilli_engine__parser__tests__snapshot_function_with_while.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_mixed_declarations.snap => submilli_engine__parser__tests__snapshot_mixed_declarations.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_multi_call_program.snap => submilli_engine__parser__tests__snapshot_multi_call_program.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_multi_error_render.snap => submilli_engine__parser__tests__snapshot_multi_error_render.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_object_and_array_literals.snap => submilli_engine__parser__tests__snapshot_object_and_array_literals.snap} (100%) rename crates/interpreter/src/snapshots/{interpreter__parser__tests__snapshot_union_type_mix.snap => submilli_engine__parser__tests__snapshot_union_type_mix.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__expr__tests__snapshot_mixed_program.snap => submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap => submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap => submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap => submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap => submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__interface_renders_properties.snap => submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap => submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap => submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap => submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__function_arity_diff.snap => submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap => submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__function_param_type_diff.snap => submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__function_return_type_diff.snap => submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap => submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__object_extra_field.snap => submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap => submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap} (100%) rename crates/interpreter/src/typechecker/infer/snapshots/{interpreter__typechecker__infer__type_diff__tests__object_missing_field.snap => submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap} (100%) create mode 100644 crates/submilli-policy/README.md diff --git a/.agents/skills/release/SKILL.md b/.agents/skills/release/SKILL.md index 43bf52ce2..8d985ee8c 100644 --- a/.agents/skills/release/SKILL.md +++ b/.agents/skills/release/SKILL.md @@ -123,7 +123,7 @@ not satisfy these gates. ```sh SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_TEST_NIGHTLY_ONLY=1 \ - cargo test --locked -p interpreter --test determinism -- --nocapture + cargo test --locked -p submilli-engine --test determinism -- --nocapture ``` `SUBMILLI_FULL_TEST` does not enable determinism. Require successful execution @@ -157,7 +157,7 @@ not satisfy these gates. ```sh SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_TEST_NIGHTLY_ONLY=1 \ - cargo test --locked -p interpreter --test type_limits -- --nocapture + cargo test --locked -p submilli-engine --test type_limits -- --nocapture ``` Require all test bodies to execute successfully. Record the candidate and @@ -166,7 +166,7 @@ not satisfy these gates. ```sh SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_TEST_NIGHTLY_ONLY=1 \ - cargo test --locked -p interpreter --test git_memory -- --nocapture + cargo test --locked -p submilli-engine --test git_memory -- --nocapture ``` Require both memory-limit test bodies to execute successfully. The optional @@ -176,7 +176,7 @@ not satisfy these gates. ```sh SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_TEST_NIGHTLY_ONLY=1 \ - cargo test --locked -p interpreter --test host_memory -- --nocapture + cargo test --locked -p submilli-engine --test host_memory -- --nocapture SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_TEST_NIGHTLY_ONLY=1 \ cargo test --locked -p submilli-server --test memory_cap -- --nocapture ``` diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index ceb3a580f..c8f441bde 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,6 +38,12 @@ jobs: - name: Clippy (gate) run: cargo clippy --workspace --all-targets -- -D warnings + # The engine and the policy crate are published to crates.io. Packaging + # builds them from the packaged files alone, so a source file left out of + # the package fails here rather than at release. + - name: Package for crates.io + run: cargo publish --dry-run --locked -p submilli-engine -p submilli-policy + # The fixture harness defaults to a smoke subset (196 of 1054) for fast local # iteration. CI has no such constraint — the full sweep is a few seconds — and # the subset keeps one fixture per top-level directory, so whole trees never run. @@ -87,7 +93,7 @@ jobs: - uses: Swatinem/rust-cache@v2 - name: VFS containment suite - run: cargo test -p interpreter --test vfs_containment + run: cargo test -p submilli-engine --test vfs_containment - name: Skill installation across platforms run: cargo test -p submilli --test skill --test upgrade @@ -108,7 +114,7 @@ jobs: # Unicode aliases, and identity read through a handle on Windows. - name: VFS mounts run: >- - cargo test -p interpreter --lib -- + cargo test -p submilli-engine --lib -- stdlib::fs::tests::mount stdlib::git::integration_tests::mount # The size limit keys files by device and inode, which Windows reports only @@ -118,7 +124,7 @@ jobs: # writers hold open. - name: VFS size limit run: >- - cargo test -p interpreter --lib -- + cargo test -p submilli-engine --lib -- runtime::vfs::tests::size_limit runtime::vfs::tests::measuring runtime::vfs::tests::a_tree stdlib::fs::tests::size_limit stdlib::fs::tests::a_ stdlib::fs::tests::copying_ stdlib::fs::tests::rewriting_ stdlib::code::tests::edits_are_counted diff --git a/.github/workflows/conformance.yml b/.github/workflows/conformance.yml index 9bc4d7339..af50d675a 100644 --- a/.github/workflows/conformance.yml +++ b/.github/workflows/conformance.yml @@ -29,16 +29,16 @@ jobs: run: cargo test --locked -p conformance --test typescript -- --nocapture - name: Compiler determinism if: ${{ !cancelled() }} - run: cargo test --locked -p interpreter --test determinism -- --nocapture + run: cargo test --locked -p submilli-engine --test determinism -- --nocapture - name: Compiler type limits if: ${{ !cancelled() }} - run: cargo test --locked -p interpreter --test type_limits -- --nocapture + run: cargo test --locked -p submilli-engine --test type_limits -- --nocapture - name: Git memory limits if: ${{ !cancelled() }} - run: cargo test --locked -p interpreter --test git_memory -- --nocapture + run: cargo test --locked -p submilli-engine --test git_memory -- --nocapture - name: Host memory bounds if: ${{ !cancelled() }} - run: cargo test --locked -p interpreter --test host_memory -- --nocapture + run: cargo test --locked -p submilli-engine --test host_memory -- --nocapture - name: Server memory caps if: ${{ !cancelled() }} run: cargo test --locked -p submilli-server --test memory_cap -- --nocapture diff --git a/AGENTS.md b/AGENTS.md index 2dfdfe5b2..64feda709 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -301,7 +301,7 @@ Whenever modifying the Git standard library (`crates/interpreter/src/stdlib/git/ run the Git memory-limit tests in addition to other affected checks: ```sh -SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_FULL_TEST=0 SUBMILLI_TEST_NIGHTLY_ONLY=1 cargo test --locked -p interpreter --test git_memory -- --nocapture +SUBMILLI_SKIP_HTTP_TESTS=1 SUBMILLI_FULL_TEST=0 SUBMILLI_TEST_NIGHTLY_ONLY=1 cargo test --locked -p submilli-engine --test git_memory -- --nocapture ``` These tests use an in-process HTTP transport backed by local `git upload-pack`, @@ -372,7 +372,7 @@ modes with synthetic package tests and a focused localhost test; contact real APIs only when their integration behavior is affected. Select the affected crate/test or package rather than all network integrations, -for example `SUBMILLI_SKIP_HTTP_TESTS=0 cargo test -p interpreter --test http_live` +for example `SUBMILLI_SKIP_HTTP_TESTS=0 cargo test -p submilli-engine --test http_live` or `cargo run -p submilli -- build test -p @submilli/jina --env-var JINA_API_KEY`. These tests may require execution outside the sandbox, even for local listeners. Request network access only for selected checks that require it. Record why HTTP diff --git a/Cargo.lock b/Cargo.lock index 59799ab61..3d2d9e3e7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -998,7 +998,7 @@ dependencies = [ name = "conformance" version = "0.3.0" dependencies = [ - "interpreter", + "submilli-engine", "submilli-wasm", "tokio", ] @@ -3239,57 +3239,6 @@ dependencies = [ "tempfile", ] -[[package]] -name = "interpreter" -version = "0.3.0" -dependencies = [ - "async-trait", - "base64 0.22.1", - "cap-fs-ext", - "cap-primitives", - "cap-std", - "filetime", - "flate2", - "futures", - "getrandom 0.2.17", - "gimli 0.33.0", - "gix", - "globset", - "hmac 0.12.1", - "httpmock", - "ignore", - "insta", - "ipnet", - "jiff", - "jiff-tzdb", - "libc", - "num-bigint", - "num-traits", - "percent-encoding", - "pollster", - "regex", - "regex-syntax", - "reqwest", - "serde", - "serde_json", - "sha2 0.10.9", - "similar", - "submilli-wasm", - "tempfile", - "tokio", - "tokio-rustls", - "unicode-ident", - "unicode-normalization", - "unicode-width", - "ureq", - "url", - "uuid", - "wasm-encoder 0.248.0", - "wasmparser 0.248.0", - "wast", - "zstd", -] - [[package]] name = "io-extras" version = "0.19.0" @@ -5436,7 +5385,6 @@ dependencies = [ "futures", "getrandom 0.2.17", "hmac 0.12.1", - "interpreter", "ipnet", "libc", "notify-debouncer-mini", @@ -5450,6 +5398,7 @@ dependencies = [ "sha2 0.10.9", "submilli-blueprint", "submilli-build", + "submilli-engine", "submilli-server", "submilli-shared", "submilli-wasm", @@ -5482,25 +5431,76 @@ dependencies = [ name = "submilli-build" version = "0.3.0" dependencies = [ - "interpreter", "serde", "serde_json", "serde_yml", "submilli-blueprint", + "submilli-engine", "tempfile", "toml", ] +[[package]] +name = "submilli-engine" +version = "0.3.0" +dependencies = [ + "async-trait", + "base64 0.22.1", + "cap-fs-ext", + "cap-primitives", + "cap-std", + "filetime", + "flate2", + "futures", + "getrandom 0.2.17", + "gimli 0.33.0", + "gix", + "globset", + "hmac 0.12.1", + "httpmock", + "ignore", + "insta", + "ipnet", + "jiff", + "jiff-tzdb", + "libc", + "num-bigint", + "num-traits", + "percent-encoding", + "pollster", + "regex", + "regex-syntax", + "reqwest", + "serde", + "serde_json", + "sha2 0.10.9", + "similar", + "submilli-wasm", + "tempfile", + "tokio", + "tokio-rustls", + "unicode-ident", + "unicode-normalization", + "unicode-width", + "ureq", + "url", + "uuid", + "wasm-encoder 0.248.0", + "wasmparser 0.248.0", + "wast", + "zstd", +] + [[package]] name = "submilli-policy" version = "0.3.0" dependencies = [ "async-trait", "base64 0.22.1", - "interpreter", "regex", "serde", "serde_json", + "submilli-engine", "tokio", "url", ] @@ -5518,7 +5518,6 @@ dependencies = [ "http-body-util", "httpmock", "insta", - "interpreter", "ipnet", "jiff", "libc", @@ -5535,6 +5534,7 @@ dependencies = [ "sqlx", "submilli-blueprint", "submilli-build", + "submilli-engine", "submilli-shared", "submilli-wasm", "subtle", @@ -5565,7 +5565,6 @@ dependencies = [ "futures", "http 1.4.0", "httpmock", - "interpreter", "rcgen", "reqwest", "rmcp", @@ -5576,6 +5575,7 @@ dependencies = [ "sse-stream", "submilli-blueprint", "submilli-build", + "submilli-engine", "submilli-policy", "tar", "tempfile", diff --git a/crates/conformance/Cargo.toml b/crates/conformance/Cargo.toml index 2ce2745f8..fa40f8a12 100644 --- a/crates/conformance/Cargo.toml +++ b/crates/conformance/Cargo.toml @@ -10,6 +10,6 @@ publish.workspace = true workspace = true [dev-dependencies] -interpreter = { path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../interpreter" } tokio = { workspace = true, features = ["rt"] } wasmtime = { workspace = true } diff --git a/crates/interpreter/Cargo.toml b/crates/interpreter/Cargo.toml index b46965bc0..1112a1be6 100644 --- a/crates/interpreter/Cargo.toml +++ b/crates/interpreter/Cargo.toml @@ -1,10 +1,16 @@ [package] -name = "interpreter" +name = "submilli-engine" +description = "Compiles Submilli programs, a TypeScript subset, to WebAssembly and runs them under capability policy" version.workspace = true edition.workspace = true license.workspace = true repository.workspace = true -publish.workspace = true +readme = "README.md" +keywords = ["submilli", "typescript", "webassembly", "sandbox", "agents"] +categories = ["compilers", "wasm"] +publish = true +# Tests and their snapshots stay in the repository; the package is the library. +exclude = ["tests/**", "**/snapshots/**"] [lints] workspace = true diff --git a/crates/interpreter/README.md b/crates/interpreter/README.md new file mode 100644 index 000000000..a9c9d5940 --- /dev/null +++ b/crates/interpreter/README.md @@ -0,0 +1,14 @@ +# submilli-engine + +The engine behind [Submilli](https://github.com/submilli/submilli-runtime): it +compiles Submilli programs, a subset of TypeScript, to WebAssembly and runs +them in a sandbox where every effect goes through a capability check. + +An embedder chooses the standard library its programs see with `Stdlib`, and +supplies the host services through traits on the store: the policy +(`SecurityCheck`), HTTP, secrets, model calls (`LlmProvider`), sub-agents +(`AgentProvider`) and skills (`SkillProvider`), among others. The policy +engine that implements `SecurityCheck` from permission rules is +[`submilli-policy`](https://crates.io/crates/submilli-policy). + +Licensed under Apache-2.0. diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__assert_false_throws_with_backtrace.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__assert_false_throws_with_backtrace.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_die_snapshot.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_die_snapshot.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_line_program_covers_helper.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_line_program_covers_helper.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_line_program_snapshot.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_line_program_snapshot.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_subprograms_for_each_user_function.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__dwarf_subprograms_for_each_user_function.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__multi_frame_backtrace.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__multi_frame_backtrace.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap diff --git a/crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap similarity index 100% rename from crates/interpreter/src/codegen/snapshots/interpreter__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap diff --git a/crates/interpreter/src/snapshots/interpreter__asi__tests__mvp_fixture_snapshot.snap b/crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__asi__tests__mvp_fixture_snapshot.snap rename to crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_clamps_at_eof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_clamps_at_eof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_clamps_at_sof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_clamps_at_sof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multiline_span_carets.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multiline_span_carets.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multiple_helps.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_multiple_helps.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_single_line_error.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_single_line_error.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_warning_severity.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_warning_severity.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_with_help.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_with_help.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_with_help_and_notes.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_with_help_and_notes.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap diff --git a/crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_zero_length_span_at_eof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__diagnostics__tests__render_zero_length_span_at_eof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap diff --git a/crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_bare_exponent_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_bare_exponent_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap diff --git a/crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_unterminated_string_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_unterminated_string_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap diff --git a/crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_unterminated_template_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__lexer__tests__renders_unterminated_template_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap diff --git a/crates/interpreter/src/snapshots/interpreter__lexer__tests__tokenize_mvp_fixture.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__lexer__tests__tokenize_mvp_fixture.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__full_precedence_chain_snapshot.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__full_precedence_chain_snapshot.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__parse_sequence_of_atoms.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__parse_sequence_of_atoms.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_else_if_chain.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_else_if_chain.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_declaration.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_declaration.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_with_if_and_return.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_with_if_and_return.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_with_while.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_function_with_while.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_mixed_declarations.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_mixed_declarations.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_multi_call_program.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_multi_call_program.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_multi_error_render.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_multi_error_render.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_object_and_array_literals.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_object_and_array_literals.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap diff --git a/crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_union_type_mix.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap similarity index 100% rename from crates/interpreter/src/snapshots/interpreter__parser__tests__snapshot_union_type_mix.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__expr__tests__snapshot_mixed_program.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__expr__tests__snapshot_mixed_program.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_renders_properties.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_renders_properties.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_arity_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_arity_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_param_type_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_param_type_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_return_type_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__function_return_type_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_extra_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_extra_field.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap diff --git a/crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_missing_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap similarity index 100% rename from crates/interpreter/src/typechecker/infer/snapshots/interpreter__typechecker__infer__type_diff__tests__object_missing_field.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap diff --git a/crates/interpreter/tests/checked_arena.rs b/crates/interpreter/tests/checked_arena.rs index f5e6f5803..bb8b80c3c 100644 --- a/crates/interpreter/tests/checked_arena.rs +++ b/crates/interpreter/tests/checked_arena.rs @@ -1,4 +1,4 @@ -use interpreter::{ +use submilli_engine::{ Ast, Expr, ExprId, ExprKind, FileId, Span, Stmt, StmtId, StmtKind, Type, TypedAst, TypedExpr, TypedExprKind, TypedStmt, TypedStmtKind, arena::{ArenaError, ArenaKind, ArenaOperation}, diff --git a/crates/interpreter/tests/checked_rendering.rs b/crates/interpreter/tests/checked_rendering.rs index 69f76ca5b..55c8fc711 100644 --- a/crates/interpreter/tests/checked_rendering.rs +++ b/crates/interpreter/tests/checked_rendering.rs @@ -1,6 +1,6 @@ //! Malformed renderer inputs are injected internal state, not guest exploits. -use interpreter::rendering::{RenderError, RenderLimits, TRUNCATED}; -use interpreter::{Diagnostic, FileId, Severity, Sources, Span, Type}; +use submilli_engine::rendering::{RenderError, RenderLimits, TRUNCATED}; +use submilli_engine::{Diagnostic, FileId, Severity, Sources, Span, Type}; fn diagnostic(span: Span, message: String) -> Diagnostic { Diagnostic { @@ -30,16 +30,16 @@ fn invalid_metadata_preserves_original_failure_and_next_render_succeeds() { ] { let diag = diagnostic(span, "original failure".into()); assert!(matches!( - interpreter::diagnostics::render_checked(&diag, &sources), + submilli_engine::diagnostics::render_checked(&diag, &sources), Err(RenderError::Source(_)) )); - let fallback = interpreter::diagnostics::render(&diag, &sources); + let fallback = submilli_engine::diagnostics::render(&diag, &sources); assert!(fallback.contains("original failure")); assert!(fallback.contains("internal reporting failure")); assert!(!fallback.contains("test.ts:")); } let good = diagnostic(Span::new(file, 0, 2).unwrap(), "healthy error".into()); - let rendered = interpreter::diagnostics::render_checked(&good, &sources).unwrap(); + let rendered = submilli_engine::diagnostics::render_checked(&good, &sources).unwrap(); assert!(rendered.text.contains("test.ts:1:1")); assert!(!rendered.truncated); } @@ -52,7 +52,7 @@ fn huge_source_context_and_many_diagnostics_share_limits() { Span::new(file, 0, source.len() as u32).unwrap(), "original failure".into(), ); - let rendered = interpreter::diagnostics::render_checked(&diag, &sources).unwrap(); + let rendered = submilli_engine::diagnostics::render_checked(&diag, &sources).unwrap(); assert!(rendered.truncated); assert!(rendered.text.len() <= RenderLimits::default().bytes); assert!(rendered.text.contains("original failure")); @@ -60,10 +60,11 @@ fn huge_source_context_and_many_diagnostics_share_limits() { diag.span = Span::at(FileId::COMPILER); diag.message = "large error ".repeat(10_000); let diagnostics = vec![diag; 100]; - let collection = interpreter::diagnostics::render_collection(&diagnostics, &sources).unwrap(); + let collection = + submilli_engine::diagnostics::render_collection(&diagnostics, &sources).unwrap(); assert!(collection.truncated); assert!(collection.text.len() <= RenderLimits::collection().bytes); - let list = interpreter::diagnostics::render_list(&diagnostics, &sources).unwrap(); + let list = submilli_engine::diagnostics::render_list(&diagnostics, &sources).unwrap(); assert!(list.iter().map(String::len).sum::() <= RenderLimits::collection().bytes); assert!(list.last().unwrap().contains(TRUNCATED)); } @@ -102,7 +103,7 @@ fn type_depth_boundary_and_wide_types_abbreviate() { .unwrap() .truncated ); - let wide = Type::Tuple(interpreter::TupleType { + let wide = Type::Tuple(submilli_engine::TupleType { elements: vec![Type::Number; 100_000], optional: 0, }); @@ -173,11 +174,11 @@ fn oversized_message_does_not_hide_an_invalid_note() { diag.notes .push((Span::at(FileId(999)), "invalid note".into())); assert!(matches!( - interpreter::diagnostics::render_checked(&diag, &sources), + submilli_engine::diagnostics::render_checked(&diag, &sources), Err(RenderError::Source(_)) )); diag.notes = vec![(Span::at(file), "valid note".into()); 100_000]; - let rendered = interpreter::diagnostics::render_checked(&diag, &sources).unwrap(); + let rendered = submilli_engine::diagnostics::render_checked(&diag, &sources).unwrap(); assert!(rendered.truncated); assert!(rendered.text.contains("primary error")); } diff --git a/crates/interpreter/tests/checked_source.rs b/crates/interpreter/tests/checked_source.rs index ccbd6fb7f..fa9a6211e 100644 --- a/crates/interpreter/tests/checked_source.rs +++ b/crates/interpreter/tests/checked_source.rs @@ -1,4 +1,4 @@ -use interpreter::{ +use submilli_engine::{ Ast, Expr, ExprKind, FileId, LineIndex, Sources, Span, StmtKind, Type, TypeAnnotationKind, TypedAst, TypedExpr, TypedExprKind, compiler_error::{CompileError, CompilerFailure, CompilerStage}, @@ -68,7 +68,7 @@ fn checked_source_errors_preserve_classification_and_have_no_false_location() { let diagnostics = CompileError::from(failure).into_diagnostics(FileId(0)); assert_eq!(diagnostics[0].span, Span::at(FileId::COMPILER)); let (sources, _) = Sources::single("script.ts", "first line").unwrap(); - let rendered = interpreter::diagnostics::render(&diagnostics[0], &sources); + let rendered = submilli_engine::diagnostics::render(&diagnostics[0], &sources); assert!(rendered.contains("internal compiler failure")); assert!(!rendered.contains("first line")); assert!(!rendered.contains("script.ts:1:1")); @@ -95,14 +95,14 @@ fn checked_source_diagnostics_preserve_original_error_on_bad_metadata() { }, Span::at(FileId(999)), ] { - let diagnostic = interpreter::Diagnostic { - severity: interpreter::Severity::Error, + let diagnostic = submilli_engine::Diagnostic { + severity: submilli_engine::Severity::Error, span, message: "original failure".into(), help: vec![], notes: vec![], }; - let rendered = interpreter::diagnostics::render(&diagnostic, &sources); + let rendered = submilli_engine::diagnostics::render(&diagnostic, &sources); assert!(rendered.contains("original failure")); assert!(rendered.contains("source context unavailable")); assert!(!rendered.contains("script.ts:")); @@ -134,20 +134,21 @@ fn checked_source_registration_keeps_text_and_file_identity_together() { fn checked_source_inference_rejects_corrupt_type_metadata_before_resolution() { let source = "function main(x: number): number { return x; }"; for corrupt in 0..3 { - let parsed = interpreter::parse_script(source, FileId(0)); + let parsed = submilli_engine::parse_script(source, FileId(0)); assert!(!parsed.has_errors()); // Parse separately because ParsedScript intentionally encapsulates its AST. - let mut lexer = interpreter::Asi::new(source, FileId(0)); + let mut lexer = submilli_engine::Asi::new(source, FileId(0)); let mut tokens = Vec::new(); loop { let token = lexer.next_token(); - let eof = matches!(token.kind, interpreter::TokenKind::Eof); + let eof = matches!(token.kind, submilli_engine::TokenKind::Eof); tokens.push(token); if eof { break; } } - let (mut ast, _) = interpreter::parser::parse_checked(source, tokens, FileId(0)).unwrap(); + let (mut ast, _) = + submilli_engine::parser::parse_checked(source, tokens, FileId(0)).unwrap(); let root = ast.top_level[0]; let StmtKind::Function { params, .. } = &mut ast.try_stmt_mut(root).unwrap().kind else { panic!("function"); @@ -167,7 +168,7 @@ fn checked_source_inference_rejects_corrupt_type_metadata_before_resolution() { } } } - let error = interpreter::typechecker::infer::infer_with_transitive_checked( + let error = submilli_engine::typechecker::infer::infer_with_transitive_checked( source, "main", &ast, @@ -185,7 +186,7 @@ fn checked_source_inference_rejects_corrupt_type_metadata_before_resolution() { )); assert!(error.to_string().contains("invalid source span")); } - interpreter::compile::typecheck_checked("function main(): number { return 1; }", FileId(0)) + submilli_engine::compile::typecheck_checked("function main(): number { return 1; }", FileId(0)) .unwrap(); } @@ -198,8 +199,9 @@ fn checked_source_codegen_rejects_invalid_spans_before_emission() { span: Span::new(FileId(9), 0, 0).unwrap(), }) .unwrap(); - let error = interpreter::codegen::codegen_with_type_info("", "script.ts", FileId(0), &ast, &[]) - .unwrap_err(); + let error = + submilli_engine::codegen::codegen_with_type_info("", "script.ts", FileId(0), &ast, &[]) + .unwrap_err(); assert!(matches!( error, CompilerFailure::Internal { @@ -229,11 +231,11 @@ fn checked_source_direct_ast_validation_checks_unreachable_nodes_too() { fn checked_source_multiline_unicode_docs_keep_original_positions() { let source = "/**\n * @param {string} text description\n * @capability x/op { label: \"x\",\n * other: \"é😀é😀é😀\" }\n */\nfunction main(): number { return 1; }"; let file = FileId(0); - let raw = interpreter::doc_comment::RawDoc { + let raw = submilli_engine::doc_comment::RawDoc { text: source.split("\nfunction").next().unwrap().into(), span: Span::new(file, 0, source.find("\nfunction").unwrap() as u32).unwrap(), }; - let doc = interpreter::doc_comment::parse_doc_comment(&raw).unwrap(); + let doc = submilli_engine::doc_comment::parse_doc_comment(&raw).unwrap(); assert_eq!(doc.params[0].name_span.text(source, file).unwrap(), "text"); let capability = &doc.capabilities[0]; assert_eq!( @@ -243,12 +245,13 @@ fn checked_source_multiline_unicode_docs_keep_original_positions() { .unwrap(), "other" ); - let interpreter::DocCapabilityBindingKind::Literal { span, .. } = capability.bindings[1].kind + let submilli_engine::DocCapabilityBindingKind::Literal { span, .. } = + capability.bindings[1].kind else { panic!("literal"); }; assert_eq!(span.text(source, file).unwrap(), "\"é😀é😀é😀\""); - let parsed = interpreter::parse_script(source, file); + let parsed = submilli_engine::parse_script(source, file); assert!(!parsed.has_errors(), "{parsed:?}"); } @@ -266,7 +269,7 @@ fn checked_source_doc_unicode_errors_and_empty_first_lines_keep_valid_spans() { #[test] fn checked_source_auxiliary_spans_are_validated() { - use interpreter::ast::{ + use submilli_engine::ast::{ ArrayLiteralElement, ExportedDecl, Ident, ObjectLiteralMember, PatternOrigin, }; let file = FileId(0); @@ -284,7 +287,7 @@ fn checked_source_auxiliary_spans_are_validated() { }) .unwrap(); let statement = ast - .try_push_stmt(interpreter::Stmt { + .try_push_stmt(submilli_engine::Stmt { kind: StmtKind::Block(vec![]), span: Span::at(file), }) @@ -349,7 +352,7 @@ fn checked_source_package_validates_before_import_graph_errors() { start: 5, end: 1, }; - let error = interpreter::typechecker::infer::infer_package_checked( + let error = submilli_engine::typechecker::infer::infer_package_checked( "test", "index".into(), vec![("index".into(), file, &ast)], @@ -365,7 +368,7 @@ fn checked_source_package_validates_before_import_graph_errors() { .. }) )); - let error = interpreter::typechecker::infer::infer_package_checked( + let error = submilli_engine::typechecker::infer::infer_package_checked( "test", "index".into(), vec![("index".into(), file, &ast)], @@ -399,17 +402,17 @@ fn checked_source_validates_predicate_outer_span() { } fn parse_ast(source: &str, file: FileId) -> Ast { - let mut lexer = interpreter::Asi::new(source, file); + let mut lexer = submilli_engine::Asi::new(source, file); let mut tokens = Vec::new(); loop { let token = lexer.next_token(); - let eof = matches!(token.kind, interpreter::TokenKind::Eof); + let eof = matches!(token.kind, submilli_engine::TokenKind::Eof); tokens.push(token); if eof { break; } } - interpreter::parser::parse_checked(source, tokens, file) + submilli_engine::parser::parse_checked(source, tokens, file) .unwrap() .0 } diff --git a/crates/interpreter/tests/checked_typed_phases.rs b/crates/interpreter/tests/checked_typed_phases.rs index 619f3c720..cf519d44b 100644 --- a/crates/interpreter/tests/checked_typed_phases.rs +++ b/crates/interpreter/tests/checked_typed_phases.rs @@ -1,5 +1,5 @@ //! Corrupt IDs below are injected internal state, not guest-input reproducers. -use interpreter::{ +use submilli_engine::{ ExprId, FileId, StmtId, TypedAst, TypedExprKind, TypedStmtKind, compiler_error::{CompilerFailure, CompilerStage}, }; @@ -7,7 +7,7 @@ use interpreter::{ const SOURCE: &str = "function main(): number { return 1; }"; fn typed(source: &str) -> TypedAst { - let (ast, diagnostics) = interpreter::compile::typecheck_to_typed_ast(source, FileId(0)); + let (ast, diagnostics) = submilli_engine::compile::typecheck_to_typed_ast(source, FileId(0)); assert!(diagnostics.is_empty(), "{diagnostics:?}"); ast } @@ -41,11 +41,11 @@ fn rules_and_capture_propagate_invalid_expression_and_statement_ids() { } else { ast.functions[0].body = StmtId(u32::MAX); } - assert_invalid_id(interpreter::check(&ast).unwrap_err().fatal.unwrap()); - assert_invalid_id(interpreter::capture(ast).unwrap_err()); + assert_invalid_id(submilli_engine::check(&ast).unwrap_err().fatal.unwrap()); + assert_invalid_id(submilli_engine::capture(ast).unwrap_err()); } - assert!(interpreter::check(&original).unwrap().is_empty()); - interpreter::capture(original).unwrap(); + assert!(submilli_engine::check(&original).unwrap().is_empty()); + submilli_engine::capture(original).unwrap(); } #[test] @@ -55,7 +55,7 @@ fn rules_keep_diagnostics_collected_before_a_fatal_failure() { let first = ast.functions[0].body; ast.try_stmt_mut(first).unwrap().kind = TypedStmtKind::Block(Vec::new()); ast.functions[1].body = StmtId(u32::MAX); - let error = interpreter::check(&ast).unwrap_err(); + let error = submilli_engine::check(&ast).unwrap_err(); assert_invalid_id(error.fatal.unwrap()); assert!( error @@ -80,8 +80,8 @@ fn desugaring_rejects_an_invalid_loop_body() { } } assert!(replaced); - assert_invalid_id(interpreter::desugar(ast, FileId(0)).unwrap_err()); - interpreter::desugar(original, FileId(0)).unwrap(); + assert_invalid_id(submilli_engine::desugar(ast, FileId(0)).unwrap_err()); + submilli_engine::desugar(original, FileId(0)).unwrap(); } #[test] @@ -89,7 +89,7 @@ fn indirect_arena_reads_validate_ids_even_when_metadata_exists() { let mut ast = typed(SOURCE); let id = ExprId(u32::MAX); ast.runtime_source_types - .insert(id, interpreter::Type::Number); + .insert(id, submilli_engine::Type::Number); assert!(ast.source_type(id).is_err()); assert!(ast.is_effect_free(id).is_err()); let literal = ast @@ -100,16 +100,17 @@ fn indirect_arena_reads_validate_ids_even_when_metadata_exists() { assert!(ast.is_effect_free(literal).unwrap()); assert_eq!( ast.source_type(literal).unwrap(), - &interpreter::Type::Number + &submilli_engine::Type::Number ); } #[test] fn codegen_returns_failure_instead_of_partial_wasm() { let original = - interpreter::desugar(interpreter::capture(typed(SOURCE)).unwrap(), FileId(0)).unwrap(); + submilli_engine::desugar(submilli_engine::capture(typed(SOURCE)).unwrap(), FileId(0)) + .unwrap(); let (prelude, host, internal) = - interpreter::runtime::prelude::cached_runtime_package_declarations(); + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); let dependencies: Vec<_> = prelude.iter().chain(host).chain(internal).collect(); for corrupt_expression in [false, true] { let mut ast = original.clone(); @@ -119,7 +120,7 @@ fn codegen_returns_failure_instead_of_partial_wasm() { ast.functions[0].body = StmtId(u32::MAX); } let failure = - interpreter::codegen::codegen(SOURCE, "typed.ts", FileId(0), &ast, &dependencies) + submilli_engine::codegen::codegen(SOURCE, "typed.ts", FileId(0), &ast, &dependencies) .unwrap_err(); assert!(matches!( failure, @@ -131,7 +132,7 @@ fn codegen_returns_failure_instead_of_partial_wasm() { assert_invalid_id(failure); } assert!( - !interpreter::codegen::codegen(SOURCE, "typed.ts", FileId(0), &original, &dependencies) + !submilli_engine::codegen::codegen(SOURCE, "typed.ts", FileId(0), &original, &dependencies) .unwrap() .is_empty() ); @@ -145,13 +146,13 @@ fn invalid_postfix_kind_is_a_typed_failure() { let mut replaced = false; for id in ast.expr_ids().unwrap() { if let TypedExprKind::PostfixUnary { op, .. } = &mut ast.try_expr_mut(id).unwrap().kind { - *op = interpreter::PostfixOp::NonNullAssert; + *op = submilli_engine::PostfixOp::NonNullAssert; replaced = true; } } assert!(replaced); assert!(matches!( - interpreter::desugar(ast, FileId(0)).unwrap_err(), + submilli_engine::desugar(ast, FileId(0)).unwrap_err(), CompilerFailure::Internal { stage: CompilerStage::Infer, .. @@ -161,7 +162,7 @@ fn invalid_postfix_kind_is_a_typed_failure() { #[test] fn capability_failure_retains_prior_warnings_and_does_not_return_a_filter() { - use interpreter::{ + use submilli_engine::{ DocCapability, DocCapabilityBinding, DocCapabilityBindingKind, Param, Span, Type, }; let span = Span::at(FileId(0)); @@ -184,8 +185,9 @@ fn capability_failure_retains_prior_warnings_and_does_not_return_a_filter() { }; let params = [Param::new("value", Type::Number)]; let ast = typed(SOURCE); - let error = interpreter::derive_call_site_capability(&tag, ¶ms, &ast, &[ExprId(u32::MAX)]) - .unwrap_err(); + let error = + submilli_engine::derive_call_site_capability(&tag, ¶ms, &ast, &[ExprId(u32::MAX)]) + .unwrap_err(); assert_invalid_id(error.fatal.unwrap()); assert_eq!(error.diagnostics.len(), 1); assert!(error.diagnostics[0].message.contains("unknown parameter")); @@ -195,7 +197,7 @@ fn capability_failure_retains_prior_warnings_and_does_not_return_a_filter() { .find(|id| matches!(ast.try_expr(*id).unwrap().kind, TypedExprKind::Number(_))) .unwrap(); assert!( - interpreter::derive_call_site_capability(&tag, ¶ms, &ast, &[value]) + submilli_engine::derive_call_site_capability(&tag, ¶ms, &ast, &[value]) .unwrap() .filter .is_some() @@ -250,15 +252,15 @@ fn desugaring_validates_rewritten_loop_references() { } } assert!(replaced); - assert_invalid_id(interpreter::desugar(ast, FileId(0)).unwrap_err()); + assert_invalid_id(submilli_engine::desugar(ast, FileId(0)).unwrap_err()); } - interpreter::desugar(original, FileId(0)).unwrap(); + submilli_engine::desugar(original, FileId(0)).unwrap(); } } #[test] fn desugaring_validates_postfix_operands() { - use interpreter::PostfixTarget; + use submilli_engine::PostfixTarget; for source in [ "function main(): void { const obj = { value: 1 }; obj.value++; }", "function main(): void { const arr = [1]; arr[0]++; }", @@ -289,15 +291,15 @@ fn desugaring_validates_postfix_operands() { } } assert!(replaced); - assert_invalid_id(interpreter::desugar(ast, FileId(0)).unwrap_err()); + assert_invalid_id(submilli_engine::desugar(ast, FileId(0)).unwrap_err()); } - interpreter::desugar(original, FileId(0)).unwrap(); + submilli_engine::desugar(original, FileId(0)).unwrap(); } } #[test] fn capability_failure_retains_deferred_http_warning() { - use interpreter::{ + use submilli_engine::{ DocCapability, DocCapabilityBinding, DocCapabilityBindingKind, Ident, Param, Span, Type, TypedExpr, }; @@ -340,9 +342,13 @@ fn capability_failure_retains_deferred_http_warning() { Param::new("url", Type::String), Param::new("other", Type::String), ]; - let error = - interpreter::derive_call_site_capability(&tag, ¶ms, &ast, &[dynamic, ExprId(u32::MAX)]) - .unwrap_err(); + let error = submilli_engine::derive_call_site_capability( + &tag, + ¶ms, + &ast, + &[dynamic, ExprId(u32::MAX)], + ) + .unwrap_err(); assert_invalid_id(error.fatal.unwrap()); assert_eq!(error.diagnostics.len(), 1); assert!( @@ -351,6 +357,7 @@ fn capability_failure_retains_deferred_http_warning() { .contains("cannot statically resolve the host") ); let healthy = - interpreter::derive_call_site_capability(&tag, ¶ms, &ast, &[dynamic, dynamic]).unwrap(); + submilli_engine::derive_call_site_capability(&tag, ¶ms, &ast, &[dynamic, dynamic]) + .unwrap(); assert_eq!(healthy.warnings.last(), error.diagnostics.first()); } diff --git a/crates/interpreter/tests/checked_untyped_phases.rs b/crates/interpreter/tests/checked_untyped_phases.rs index e668e6331..bd4ca782a 100644 --- a/crates/interpreter/tests/checked_untyped_phases.rs +++ b/crates/interpreter/tests/checked_untyped_phases.rs @@ -1,23 +1,23 @@ //! Injected arena corruption is an internal failure, not a language diagnostic. use std::collections::BTreeMap; -use interpreter::{ +use submilli_engine::{ Ast, ExprId, FileId, ModulePath, Sources, StmtId, StmtKind, compiler_error::{CompileError, CompilerFailure, CompilerStage}, }; fn parse(source: &str, file: FileId) -> Ast { - let mut lexer = interpreter::Asi::new(source, file); + let mut lexer = submilli_engine::Asi::new(source, file); let mut tokens = Vec::new(); loop { let token = lexer.next_token(); - let eof = matches!(token.kind, interpreter::TokenKind::Eof); + let eof = matches!(token.kind, submilli_engine::TokenKind::Eof); tokens.push(token); if eof { break; } } - interpreter::parser::parse_checked(source, tokens, file) + submilli_engine::parser::parse_checked(source, tokens, file) .unwrap() .0 } @@ -25,10 +25,11 @@ fn parse(source: &str, file: FileId) -> Ast { fn infer( source: &str, ast: &Ast, -) -> Result<(interpreter::TypedAst, Vec), CompileError> { - let (prelude, host, _) = interpreter::runtime::prelude::cached_runtime_package_declarations(); +) -> Result<(submilli_engine::TypedAst, Vec), CompileError> { + let (prelude, host, _) = + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); let packages: Vec<_> = prelude.iter().chain(host).collect(); - interpreter::typechecker::infer::infer_with_transitive_checked( + submilli_engine::typechecker::infer::infer_with_transitive_checked( source, "main", ast, @@ -55,7 +56,7 @@ fn assert_internal(error: &CompileError) { #[test] fn inference_rejects_invalid_statement_and_expression_ids() { let source = "function main(): number { return 1; }"; - let original = interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + let original = submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); for corrupt_expression in [false, true] { let mut ast = original.clone(); if corrupt_expression { @@ -76,7 +77,7 @@ fn inference_rejects_invalid_statement_and_expression_ids() { #[test] fn binding_failure_retains_earlier_language_diagnostics() { let source = "function main(): number { let value = value; return 1; }"; - let mut ast = interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + let mut ast = submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); ast.top_level.push(StmtId(u32::MAX)); let error = infer(source, &ast).unwrap_err(); assert_internal(&error); @@ -94,7 +95,7 @@ fn binding_failure_retains_earlier_language_diagnostics() { fn lowering_rejects_bad_top_level_and_pattern_body_ids() { let mut ast = Ast::new(); ast.top_level.push(StmtId(u32::MAX)); - let error = interpreter::lower_patterns(ast).unwrap_err(); + let error = submilli_engine::lower_patterns(ast).unwrap_err(); assert_internal(&error.into()); let source = "function main([x]: number[]): number { return x; }"; @@ -104,14 +105,14 @@ fn lowering_rejects_bad_top_level_and_pattern_body_ids() { panic!("function") }; *body = StmtId(u32::MAX); - assert_internal(&interpreter::lower_patterns(ast).unwrap_err().into()); - interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + assert_internal(&submilli_engine::lower_patterns(ast).unwrap_err().into()); + submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); } #[test] fn export_metadata_reads_are_checked_after_binding_analysis() { let source = "export function value(): number { return 1; }"; - let mut ast = interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + let mut ast = submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); ast.exported_decls[0].stmt = StmtId(u32::MAX); assert_internal(&infer(source, &ast).unwrap_err()); } @@ -122,9 +123,9 @@ fn package_graph_failure_preserves_earlier_import_diagnostic() { let source = "import { value } from './missing'; export function read(): number { return value(); }"; let file = sources.add("lib.ts", source).unwrap(); - let mut ast = interpreter::lower_patterns(parse(source, file)).unwrap(); + let mut ast = submilli_engine::lower_patterns(parse(source, file)).unwrap(); ast.top_level.push(StmtId(u32::MAX)); - let error = interpreter::typechecker::infer::infer_package_checked( + let error = submilli_engine::typechecker::infer::infer_package_checked( "test", ModulePath::from("lib"), vec![(ModulePath::from("lib"), file, &ast)], @@ -150,21 +151,22 @@ fn later_module_arena_failure_preserves_earlier_module_diagnostics() { let last = "export function read(): number { return 1; }"; let first_file = sources.add("a.ts", first).unwrap(); let last_file = sources.add("lib.ts", last).unwrap(); - let first_ast = interpreter::lower_patterns(parse(first, first_file)).unwrap(); - let mut last_ast = interpreter::lower_patterns(parse(last, last_file)).unwrap(); + let first_ast = submilli_engine::lower_patterns(parse(first, first_file)).unwrap(); + let mut last_ast = submilli_engine::lower_patterns(parse(last, last_file)).unwrap(); let root = last_ast.top_level[0]; let StmtKind::Function { body, .. } = &mut last_ast.try_stmt_mut(root).unwrap().kind else { panic!("function") }; *body = StmtId(u32::MAX); - let (prelude, host, _) = interpreter::runtime::prelude::cached_runtime_package_declarations(); + let (prelude, host, _) = + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); let packages = prelude .iter() .chain(host) .cloned() .map(|p| (p.package_name.clone(), p)) .collect(); - let error = interpreter::typechecker::infer::infer_package_checked( + let error = submilli_engine::typechecker::infer::infer_package_checked( "test", ModulePath::from("lib"), vec![ @@ -186,9 +188,9 @@ fn later_module_arena_failure_preserves_earlier_module_diagnostics() { #[test] fn inference_rejects_wrong_node_kinds_without_losing_prior_diagnostics() { - use interpreter::ExprKind; + use submilli_engine::ExprKind; let source = "function main(): number { let early = early; let x = 0; return (x = 1); }"; - let mut ast = interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + let mut ast = submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); let target = ast .expr_ids() .unwrap() @@ -214,13 +216,13 @@ fn inference_rejects_wrong_node_kinds_without_losing_prior_diagnostics() { #[test] fn inference_rejects_wrong_function_and_loop_body_kinds() { - use interpreter::ExprKind; + use submilli_engine::ExprKind; for source in [ "function main(): number { const f = function(): number { return 1; }; return f(); }", "function main(): number { while (false) { return 1; } return 0; }", "function main(): number { return 1; }", ] { - let mut ast = interpreter::lower_patterns(parse(source, FileId(0))).unwrap(); + let mut ast = submilli_engine::lower_patterns(parse(source, FileId(0))).unwrap(); if source.contains("const f") { let function = ast .expr_ids() @@ -292,7 +294,7 @@ fn inference_fits_production_worker_stack() { &equality_chain, "function main(): number { return 42; }", ] { - let compiled = interpreter::compile::compile_script_checked( + let compiled = submilli_engine::compile::compile_script_checked( source, "stack.ts", FileId(0), diff --git a/crates/interpreter/tests/class_rec_group.rs b/crates/interpreter/tests/class_rec_group.rs index 3feb21f42..3a511f029 100644 --- a/crates/interpreter/tests/class_rec_group.rs +++ b/crates/interpreter/tests/class_rec_group.rs @@ -5,7 +5,7 @@ //! must still validate, and the per-class struct + vtable types must appear in //! the emitted rec group with the expected `$ObjectShape`/`$VTable` nesting. -use interpreter::{FileId, compile_script}; +use submilli_engine::{FileId, compile_script}; use wasmparser::{CompositeInnerType, Parser, Payload, Validator}; fn compile(source: &str) -> Vec { diff --git a/crates/interpreter/tests/closure_arity.rs b/crates/interpreter/tests/closure_arity.rs index 50086da11..53ba9e1aa 100644 --- a/crates/interpreter/tests/closure_arity.rs +++ b/crates/interpreter/tests/closure_arity.rs @@ -1,11 +1,11 @@ //! Supported closure ABI boundaries; rejection cases live in closure_arity_diagnostics. -use interpreter::compiler_limits::MAX_CLOSURE_ARITY; -use interpreter::runtime::{ +use submilli_engine::compiler_limits::MAX_CLOSURE_ARITY; +use submilli_engine::runtime::{ LinkedPackageModule, StoreData, Vfs, install_package_modules_async, install_runtime_async, install_tenant_limits, }; -use interpreter::{ +use submilli_engine::{ CompiledPackage, FileId, ModulePath, PackageSourceModule, RuntimeConfig, compile_package, compile_script, dispatch_main_async, }; diff --git a/crates/interpreter/tests/closure_arity_diagnostics.rs b/crates/interpreter/tests/closure_arity_diagnostics.rs index d6c755be2..f718c53b5 100644 --- a/crates/interpreter/tests/closure_arity_diagnostics.rs +++ b/crates/interpreter/tests/closure_arity_diagnostics.rs @@ -1,6 +1,10 @@ //! Source validation must run during check, before lowering to Wasm. -use interpreter::compile::{compile_package_checked, compile_script_checked, typecheck_checked}; -use interpreter::{Diagnostic, FileId, ModulePath, PackageSourceModule, Severity, Type, ValueKind}; +use submilli_engine::compile::{ + compile_package_checked, compile_script_checked, typecheck_checked, +}; +use submilli_engine::{ + Diagnostic, FileId, ModulePath, PackageSourceModule, Severity, Type, ValueKind, +}; fn parameters(arity: usize) -> String { (0..arity) @@ -96,7 +100,7 @@ fn constructors_keep_their_own_abi() { compile_script_checked(&source, "constructor.ts", FileId(0), &[], &[]).unwrap(); } -fn imported_declaration() -> interpreter::PackageDeclaration { +fn imported_declaration() -> submilli_engine::PackageDeclaration { compile_package_checked("aritydep", ModulePath::from("lib"), &[PackageSourceModule { path: ModulePath::from("lib"), source: "export function bad(a: number): number { return a; } export function healthy(): number { return 42; }", @@ -111,7 +115,7 @@ fn imported_signatures_are_checked_on_use_and_unused_surface_is_allowed() { panic!("function") }; *params = (0..256) - .map(|i| interpreter::Param::new(format!("a{i}"), Type::Number)) + .map(|i| submilli_engine::Param::new(format!("a{i}"), Type::Number)) .collect(); // Keep the physical ABI consistent so this tests payload arity, not corrupt metadata. let runtime_name = declaration.values.get("bad").unwrap().mangled_name.clone(); @@ -231,13 +235,13 @@ fn imported_interface_methods_are_validated_when_dispatched() { path: ModulePath::from("lib"), source: "export interface I { f(): number; } export function get(): I { return { f: (): number => 42 }; }", }], &[]).unwrap().declaration; - let interpreter::TypeKind::Interface { methods, .. } = + let submilli_engine::TypeKind::Interface { methods, .. } = &mut declaration.types.get_mut("I").unwrap().kind else { panic!("interface") }; methods.get_mut("f").unwrap().params = (0..256) - .map(|i| interpreter::Param::new(format!("a{i}"), Type::Number)) + .map(|i| submilli_engine::Param::new(format!("a{i}"), Type::Number)) .collect(); let args = (0..256) .map(|i| i.to_string()) @@ -312,7 +316,7 @@ fn static_only_class_usage_checks_required_callable_payloads() { path: ModulePath::from("lib"), source: "export class C { static f: (a: number) => number = (a: number): number => a; static healthy(): number { return 42; } }", }], &[]).unwrap().declaration; - let interpreter::TypeKind::Class { static_fields, .. } = + let submilli_engine::TypeKind::Class { static_fields, .. } = &mut declaration.types.get_mut("C").unwrap().kind else { panic!("class") @@ -339,13 +343,13 @@ fn static_calls_validate_unmentioned_instance_method_payloads() { path: ModulePath::from("lib"), source: "export class C { f(): number { return 42; } static healthy(): number { return 42; } }", }], &[]).unwrap().declaration; - let interpreter::TypeKind::Class { methods, .. } = + let submilli_engine::TypeKind::Class { methods, .. } = &mut declaration.types.get_mut("C").unwrap().kind else { panic!("class") }; methods.get_mut("f").unwrap().params = (0..256) - .map(|i| interpreter::Param::new(format!("a{i}"), Type::Number)) + .map(|i| submilli_engine::Param::new(format!("a{i}"), Type::Number)) .collect(); let source = "import { C } from \"aritydep\"; function main(): number { return C.healthy(); }"; let error = @@ -363,7 +367,7 @@ fn raw_host_functions_only_need_the_limit_when_adapted_to_closures() { panic!("function") }; *params = (0..256) - .map(|i| interpreter::Param::new(format!("a{i}"), Type::Number)) + .map(|i| submilli_engine::Param::new(format!("a{i}"), Type::Number)) .collect(); let args = (0..256) .map(|i| i.to_string()) @@ -434,7 +438,7 @@ fn inherited_statics_validate_the_declaring_class_only() { // Public exports and hidden runtime class surfaces share the physical signature. fn set_oversized_method( - declaration: &mut interpreter::PackageDeclaration, + declaration: &mut submilli_engine::PackageDeclaration, class: &str, method: &str, ) { @@ -445,14 +449,14 @@ fn set_oversized_method( .chain(declaration.runtime_types.values_mut()) .filter(|symbol| symbol.mangled_name == class_name) { - let interpreter::TypeKind::Class { methods, .. } = &mut symbol.kind else { + let submilli_engine::TypeKind::Class { methods, .. } = &mut symbol.kind else { panic!("class") }; methods.get_mut(method).unwrap().params = (0..256) - .map(|i| interpreter::Param::new(format!("a{i}"), Type::Number)) + .map(|i| submilli_engine::Param::new(format!("a{i}"), Type::Number)) .collect(); } - let runtime_name = interpreter::mangle::extend(&class_name, method); + let runtime_name = submilli_engine::mangle::extend(&class_name, method); declaration .runtime_functions .get_mut(&runtime_name) diff --git a/crates/interpreter/tests/closure_lowering_errors.rs b/crates/interpreter/tests/closure_lowering_errors.rs index dc2f6cb99..c2a88cda6 100644 --- a/crates/interpreter/tests/closure_lowering_errors.rs +++ b/crates/interpreter/tests/closure_lowering_errors.rs @@ -1,11 +1,11 @@ //! Compiler failures below exercise source limits and injected invalid codegen state. -use interpreter::codegen::{ +use submilli_engine::codegen::{ closures::{self, ClosureSig}, symbol_table::SymbolTable, }; -use interpreter::compile::{compile_package_checked, compile_script_checked}; -use interpreter::compiler_error::{CompilerFailure, CompilerStage}; -use interpreter::{FileId, ModulePath, PackageSourceModule, Type}; +use submilli_engine::compile::{compile_package_checked, compile_script_checked}; +use submilli_engine::compiler_error::{CompilerFailure, CompilerStage}; +use submilli_engine::{FileId, ModulePath, PackageSourceModule, Type}; fn signature(arity: usize, ret: Type) -> Type { Type::Function { diff --git a/crates/interpreter/tests/compiler_structure_limits.rs b/crates/interpreter/tests/compiler_structure_limits.rs index 44c1ec40b..89ac93dde 100644 --- a/crates/interpreter/tests/compiler_structure_limits.rs +++ b/crates/interpreter/tests/compiler_structure_limits.rs @@ -4,9 +4,9 @@ use std::process::Command; use std::time::{Duration, Instant}; -use interpreter::compiler_error::CompilerFailure; -use interpreter::compiler_limits::COMPILER_STACK_BYTES; -use interpreter::{ +use submilli_engine::compiler_error::CompilerFailure; +use submilli_engine::compiler_limits::COMPILER_STACK_BYTES; +use submilli_engine::{ FileId, compile::{compile_script_checked, typecheck_checked}, }; diff --git a/crates/interpreter/tests/console_failure.rs b/crates/interpreter/tests/console_failure.rs index f8a716212..1c76c421d 100644 --- a/crates/interpreter/tests/console_failure.rs +++ b/crates/interpreter/tests/console_failure.rs @@ -1,11 +1,11 @@ //! Console infrastructure failures must terminate execution even inside guest catch blocks. use std::io::{self, Write}; -use interpreter::runtime::host::FatalHostError; -use interpreter::runtime::{ +use submilli_engine::runtime::host::FatalHostError; +use submilli_engine::runtime::{ RuntimeConfig, StoreData, Vfs, install_runtime_async, install_tenant_limits, }; -use interpreter::{FileId, compile_script, dispatch_main_async, instantiate_program_async}; +use submilli_engine::{FileId, compile_script, dispatch_main_async, instantiate_program_async}; use wasmtime::{Linker, Module}; struct FailedWriter; @@ -23,7 +23,7 @@ impl Write for FailedWriter { #[test] fn console_writer_failure_bypasses_guest_catch_and_next_run_succeeds() { std::thread::Builder::new() - .stack_size(interpreter::compiler_limits::COMPILER_STACK_BYTES) + .stack_size(submilli_engine::compiler_limits::COMPILER_STACK_BYTES) .spawn(|| pollster::block_on(check_console_failure())) .unwrap() .join() diff --git a/crates/interpreter/tests/cross_module_gc_types.rs b/crates/interpreter/tests/cross_module_gc_types.rs index 60b99e8f9..b38d72e1b 100644 --- a/crates/interpreter/tests/cross_module_gc_types.rs +++ b/crates/interpreter/tests/cross_module_gc_types.rs @@ -2,7 +2,7 @@ use std::borrow::Cow; -use interpreter::RuntimeConfig; +use submilli_engine::RuntimeConfig; use wasm_encoder::{ BlockType, CodeSection, CompositeInnerType, CompositeType, ElementSection, Elements, ExportKind, ExportSection, FieldType, Function, FunctionSection, HeapType, ImportSection, diff --git a/crates/interpreter/tests/decision_records.rs b/crates/interpreter/tests/decision_records.rs index ba3b05def..4a9e92149 100644 --- a/crates/interpreter/tests/decision_records.rs +++ b/crates/interpreter/tests/decision_records.rs @@ -4,8 +4,9 @@ use std::sync::atomic::{AtomicU64, Ordering}; use std::sync::{Arc, Mutex}; -use interpreter::runtime::security::AuditDecision; -use interpreter::runtime::{ +use serde_json::{Value, json}; +use submilli_engine::runtime::security::AuditDecision; +use submilli_engine::runtime::{ Access, BodyCopy, CallOutcome, CallRecord, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, DecisionLog, DecisionLogConfig, DecisionLogOutput, DecisionRecord, EmbeddingBatch, EmbeddingError, EmbeddingLimits, EmbeddingModel, EmbeddingProvider, @@ -16,15 +17,14 @@ use interpreter::runtime::{ install_package_modules_async, install_runtime_host_functions, install_runtime_store_bound, install_tenant_limits, limits::ExecutionUsage, }; -use interpreter::stdlib::git::GitConfig; -use interpreter::stdlib::http::transport::{ +use submilli_engine::stdlib::git::GitConfig; +use submilli_engine::stdlib::http::transport::{ DownloadMeta, EgressAt, HttpClient, HttpError, HttpRequest, HttpResponse, RedirectHop, }; -use interpreter::{ +use submilli_engine::{ CompiledPackage, FileId, ModulePath, PackageSourceModule, RuntimeConfig, compile_package_with_transitive, compile_script, dispatch_main_async, }; -use serde_json::{Value, json}; use wasmtime::{Linker, Module}; // ---- fixtures ------------------------------------------------------------------------- @@ -502,7 +502,7 @@ impl EmbeddingProvider for FakeEmbedding { &'a self, alias: &'a str, texts: &'a [String], - _purpose: interpreter::runtime::Purpose, + _purpose: submilli_engine::runtime::Purpose, budget: &'a EmbeddingTokenBudget, ) -> std::pin::Pin< Box> + Send + 'a>, @@ -514,14 +514,14 @@ impl EmbeddingProvider for FakeEmbedding { // or after none reported usage (`dark`). let failed_after = |reported| EmbeddingError::Provider { alias: alias.to_string(), - reason: interpreter::runtime::EmbeddingFailureReason::Transport, + reason: submilli_engine::runtime::EmbeddingFailureReason::Transport, settlements: vec![ - interpreter::runtime::SubBatchSettlement { + submilli_engine::runtime::SubBatchSettlement { estimate: 4, reported, indeterminate: 4 - reported, }, - interpreter::runtime::SubBatchSettlement { + submilli_engine::runtime::SubBatchSettlement { estimate: 3, reported: 0, indeterminate: 3, @@ -542,7 +542,7 @@ impl EmbeddingProvider for FakeEmbedding { ) .expect("shape") .with_input_tokens(Some(7)) - .with_settlements(vec![interpreter::runtime::SubBatchSettlement { + .with_settlements(vec![submilli_engine::runtime::SubBatchSettlement { estimate, reported: 7, indeterminate: 0, @@ -1519,7 +1519,7 @@ function main(): string { get("https://example.test/a"); return "done"; } // ---- throwaway cost measurement --------------------------------------------------------------- -/// Run with `cargo test --release -p interpreter --test decision_records -- --ignored +/// Run with `cargo test --release -p submilli-engine --test decision_records -- --ignored /// --nocapture line_lookup_cost`; prints per-call costs, asserts nothing about time. #[tokio::test] #[ignore = "timing measurement, not a check"] @@ -1731,7 +1731,7 @@ function main(): string { return llm.call("open", "what is two plus two").text ? assert!(body_text(response.body.as_ref()).is_some_and(|t| t.contains("answer"))); assert_eq!( call.usage, - Some(interpreter::runtime::ModelUsage { + Some(submilli_engine::runtime::ModelUsage { input_tokens: Some(10), output_tokens: Some(10), }) @@ -1783,7 +1783,7 @@ function main(): string { assert_eq!(response.bytes, 2 * 4 * 4); assert_eq!( call.usage, - Some(interpreter::runtime::ModelUsage { + Some(submilli_engine::runtime::ModelUsage { input_tokens: Some(7), output_tokens: None, }) @@ -1795,7 +1795,7 @@ async fn a_failed_embed_call_keeps_the_usage_its_sent_batches_reported() { for (alias, usage) in [ ( "open-embed-flaky", - Some(interpreter::runtime::ModelUsage { + Some(submilli_engine::runtime::ModelUsage { input_tokens: Some(4), output_tokens: None, }), @@ -1872,7 +1872,7 @@ function main(): string { // The call's own usage stays the sum, absent where any prompt left a count out. assert_eq!( call.usage, - Some(interpreter::runtime::ModelUsage { + Some(submilli_engine::runtime::ModelUsage { input_tokens: Some(13), output_tokens: None, }) diff --git a/crates/interpreter/tests/determinism.rs b/crates/interpreter/tests/determinism.rs index e413c1c8d..03de9e86e 100644 --- a/crates/interpreter/tests/determinism.rs +++ b/crates/interpreter/tests/determinism.rs @@ -11,7 +11,7 @@ use std::fs; use std::path::{Path, PathBuf}; -use interpreter::{ +use submilli_engine::{ CompiledPackage, Diagnostic, FileId, ModulePath, PackageSourceModule, compile_package, compile_script, }; @@ -165,7 +165,7 @@ fn check_in_parallel(paths: Vec) -> Report { .into_iter() .map(|chunk| { std::thread::Builder::new() - .stack_size(interpreter::compiler_limits::COMPILER_STACK_BYTES) + .stack_size(submilli_engine::compiler_limits::COMPILER_STACK_BYTES) .spawn(move || find_unstable(&chunk)) .expect("spawn compile worker") }) diff --git a/crates/interpreter/tests/diagnostic_snapshots.rs b/crates/interpreter/tests/diagnostic_snapshots.rs index 61992fb74..4d2f9c0b6 100644 --- a/crates/interpreter/tests/diagnostic_snapshots.rs +++ b/crates/interpreter/tests/diagnostic_snapshots.rs @@ -2,7 +2,7 @@ //! Each test drives a small .subm program through the full pipeline and //! renders every emitted diagnostic; this file is the integration guarantee. -use interpreter::{ +use submilli_engine::{ Asi, FileId, Severity, Sources, Token, TokenKind, check, diagnostics, infer, parse, }; @@ -26,7 +26,7 @@ fn render_all(source: &str) -> String { // a partial AST would just produce cascading noise. if !diags.iter().any(|d| d.severity == Severity::Error) { let (prelude_defs, host_defs, _) = - interpreter::runtime::prelude::cached_runtime_package_declarations(); + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); let mut package_refs = Vec::with_capacity(prelude_defs.len() + host_defs.len()); package_refs.extend(prelude_defs.iter()); package_refs.extend(host_defs.iter()); diff --git a/crates/interpreter/tests/field_lookup_size.rs b/crates/interpreter/tests/field_lookup_size.rs index 5ef5e9a7e..be3a99f08 100644 --- a/crates/interpreter/tests/field_lookup_size.rs +++ b/crates/interpreter/tests/field_lookup_size.rs @@ -1,4 +1,4 @@ -use interpreter::{ModulePath, PackageSourceModule, compile_package}; +use submilli_engine::{ModulePath, PackageSourceModule, compile_package}; fn module_size(accesses: usize, write: bool) -> usize { let statement = if write { diff --git a/crates/interpreter/tests/fixtures.rs b/crates/interpreter/tests/fixtures.rs index b15089ba0..4fdbaca70 100644 --- a/crates/interpreter/tests/fixtures.rs +++ b/crates/interpreter/tests/fixtures.rs @@ -32,7 +32,7 @@ use std::io::Write; use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex}; -use interpreter::runtime::{ +use submilli_engine::runtime::{ EmbeddingBatch, EmbeddingError, EmbeddingFailureReason, EmbeddingLimits, EmbeddingMalformedReason, EmbeddingModel, EmbeddingProvider, EmbeddingTokenBudget, ExecutionTokenBudget, FailureReason, InMemorySessionKv, LinkedPackageModule, LlmCallError, @@ -40,7 +40,7 @@ use interpreter::runtime::{ StoreData, SubBatchSettlement, Vfs, estimate_embedding_tokens, install_package_modules_async, install_runtime_host_functions, install_runtime_store_bound, install_tenant_limits, }; -use interpreter::{ +use submilli_engine::{ Asi, BacktraceMode, CompiledPackage, Diagnostic, ModulePath, PackageDeclaration, PackageSourceModule, RunResult, RuntimeConfig, Sources, Token, TokenKind, compile_package_with_transitive, compile_script, diagnostics, infer_package, lower_patterns, @@ -115,7 +115,7 @@ impl PreparedRuntime { async fn run( &self, - compiled: &interpreter::compile::CompiledScript, + compiled: &submilli_engine::compile::CompiledScript, deny_capabilities: &[String], deny_llm_models: &[String], deny_embedding_models: &[String], @@ -156,7 +156,7 @@ impl PreparedRuntime { install_runtime_store_bound(&mut linker, &mut store)?; let inst = linker.instantiate_async(&mut store, &module).await?; let _watchdog = self.config.arm_timeout(&self.engine)?; - let value = interpreter::dispatch_main_async(&mut store, &inst).await?; + let value = submilli_engine::dispatch_main_async(&mut store, &inst).await?; let captured = buf.lock().unwrap().clone(); let console = String::from_utf8(captured) .map_err(|e| wasmtime::Error::msg(format!("console output not utf-8: {e}")))?; @@ -171,7 +171,7 @@ impl PreparedRuntime { async fn run_packages( &self, deps: &[&CompiledPackage], - root: &interpreter::compile::CompiledScript, + root: &submilli_engine::compile::CompiledScript, deny_capabilities: &[String], fixture: &str, ) -> wasmtime::Result { @@ -206,7 +206,7 @@ impl PreparedRuntime { let root_module = Module::new(&self.engine, &root.wasm)?; let inst = linker.instantiate_async(&mut store, &root_module).await?; let _watchdog = self.config.arm_timeout(&self.engine)?; - let value = interpreter::dispatch_main_async(&mut store, &inst).await?; + let value = submilli_engine::dispatch_main_async(&mut store, &inst).await?; Ok(RunResult { value, console: String::new(), @@ -226,7 +226,7 @@ fn run_fixtures_parallel(paths: Vec, runtime: Arc) -> let runtime = Arc::clone(&runtime); handles.push( std::thread::Builder::new() - .stack_size(interpreter::compiler_limits::COMPILER_STACK_BYTES) + .stack_size(submilli_engine::compiler_limits::COMPILER_STACK_BYTES) .spawn(move || { let tokio = tokio::runtime::Builder::new_current_thread() .enable_all() @@ -408,7 +408,7 @@ fn run_one( let filename = rel(path); let expectations = parse_expectations(&src)?; - let compiled = compile_script(&src, &filename, interpreter::FileId(0), &[], &[]); + let compiled = compile_script(&src, &filename, submilli_engine::FileId(0), &[], &[]); let diags = match &compiled { Ok(compiled) => &compiled.warnings, Err(diags) => diags, @@ -495,13 +495,13 @@ fn run_multi(path: &Path) -> Result<(), String> { owned_asts.push((module, file_id, ast)); } - let stdlib_defs = interpreter::runtime::stdlib_package_declarations(); + let stdlib_defs = submilli_engine::runtime::stdlib_package_declarations(); let mut external_packages: std::collections::BTreeMap = stdlib_defs .into_iter() .map(|defs| (defs.package_name.clone(), defs)) .collect(); let (prelude_defs, host_defs, _) = - interpreter::runtime::prelude::cached_runtime_package_declarations(); + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); for defs in prelude_defs { external_packages.insert(defs.package_name.clone(), defs.clone()); } @@ -526,7 +526,7 @@ fn run_multi(path: &Path) -> Result<(), String> { match ( all_diags .iter() - .any(|d| d.severity == interpreter::Severity::Error), + .any(|d| d.severity == submilli_engine::Severity::Error), error_needles.as_slice(), ) { (false, n) if !n.is_empty() => Err(format!( @@ -743,7 +743,7 @@ fn run_packages_fixture( let root_script = match compile_script( root_src, root_path.as_str(), - interpreter::FileId(0), + submilli_engine::FileId(0), &all_decls, &[], ) { @@ -830,7 +830,10 @@ fn assert_diagnostic_count(expected: Option, diags: &[Diagnostic]) -> Res Ok(()) } -fn parse_source(src: &str, file: interpreter::FileId) -> (interpreter::Ast, Vec) { +fn parse_source( + src: &str, + file: submilli_engine::FileId, +) -> (submilli_engine::Ast, Vec) { let mut asi = Asi::new(src, file); let mut tokens: Vec = Vec::new(); loop { @@ -1389,21 +1392,21 @@ fn install_embedding_fixture_support(data: &mut StoreData, fixture: &str) { /// where filter-conditional denial gets its integration coverage. struct FixtureDenyLlmModel(Vec); -impl interpreter::runtime::SecurityCheck for FixtureDenyLlmModel { +impl submilli_engine::runtime::SecurityCheck for FixtureDenyLlmModel { fn check( &self, _caller: &str, capability: &str, context: &serde_json::Value, - ) -> interpreter::runtime::CheckOutcome { + ) -> submilli_engine::runtime::CheckOutcome { let model = context.get("model").and_then(serde_json::Value::as_str); if capability == "llm.call" && model.is_some_and(|m| self.0.iter().any(|d| d == m)) { - return interpreter::runtime::CheckOutcome::Deny { + return submilli_engine::runtime::CheckOutcome::Deny { rule: None, reason: "denied by fixture model filter".to_string(), }; } - interpreter::runtime::CheckOutcome::Allow { rule: None } + submilli_engine::runtime::CheckOutcome::Allow { rule: None } } } @@ -1411,21 +1414,21 @@ impl interpreter::runtime::SecurityCheck for FixtureDenyLlmModel { /// `embedding.embed` for the named aliases, keyed off the check context. struct FixtureDenyEmbeddingModel(Vec); -impl interpreter::runtime::SecurityCheck for FixtureDenyEmbeddingModel { +impl submilli_engine::runtime::SecurityCheck for FixtureDenyEmbeddingModel { fn check( &self, _caller: &str, capability: &str, context: &serde_json::Value, - ) -> interpreter::runtime::CheckOutcome { + ) -> submilli_engine::runtime::CheckOutcome { let model = context.get("model").and_then(serde_json::Value::as_str); if capability == "embedding.embed" && model.is_some_and(|m| self.0.iter().any(|d| d == m)) { - return interpreter::runtime::CheckOutcome::Deny { + return submilli_engine::runtime::CheckOutcome::Deny { rule: None, reason: "denied by fixture model filter".to_string(), }; } - interpreter::runtime::CheckOutcome::Allow { rule: None } + submilli_engine::runtime::CheckOutcome::Allow { rule: None } } } @@ -1433,20 +1436,20 @@ impl interpreter::runtime::SecurityCheck for FixtureDenyEmbeddingModel { /// with a fixed reason the fixture can assert against. struct FixtureDeny(Vec); -impl interpreter::runtime::SecurityCheck for FixtureDeny { +impl submilli_engine::runtime::SecurityCheck for FixtureDeny { fn check( &self, _caller: &str, capability: &str, _context: &serde_json::Value, - ) -> interpreter::runtime::CheckOutcome { + ) -> submilli_engine::runtime::CheckOutcome { if self.0.iter().any(|needle| capability.contains(needle)) { - interpreter::runtime::CheckOutcome::Deny { + submilli_engine::runtime::CheckOutcome::Deny { rule: None, reason: "denied by fixture policy".to_string(), } } else { - interpreter::runtime::CheckOutcome::Allow { rule: None } + submilli_engine::runtime::CheckOutcome::Allow { rule: None } } } } @@ -1580,8 +1583,8 @@ fn diagnostic_count_directive_rejects_missing_and_duplicate_reports() { ) .unwrap(); let diagnostic = Diagnostic { - severity: interpreter::Severity::Error, - span: interpreter::Span::at(interpreter::FileId(0)), + severity: submilli_engine::Severity::Error, + span: submilli_engine::Span::at(submilli_engine::FileId(0)), message: "mismatch".into(), help: vec![], notes: vec![], diff --git a/crates/interpreter/tests/git_memory.rs b/crates/interpreter/tests/git_memory.rs index 56029b9b3..18a6e525b 100644 --- a/crates/interpreter/tests/git_memory.rs +++ b/crates/interpreter/tests/git_memory.rs @@ -12,11 +12,11 @@ use std::path::Path; use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::{Arc, Mutex}; -use interpreter::stdlib::git::GitConfig; -use interpreter::stdlib::http::transport::{ +use submilli_engine::stdlib::git::GitConfig; +use submilli_engine::stdlib::http::transport::{ DownloadMeta, HttpClient, HttpError, HttpRequest, HttpResponse, }; -use interpreter::{ +use submilli_engine::{ compile_script, dispatch_main_async, runtime::{RuntimeConfig, StoreData, Vfs, install_runtime_async, install_tenant_limits}, }; @@ -247,7 +247,7 @@ fn measure( seed: impl FnOnce(&Path), configure: impl FnOnce(&mut StoreData), ) -> Result { - let compiled = compile_script(src, "git_memory.ts", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(src, "git_memory.ts", submilli_engine::FileId(0), &[], &[]) .unwrap_or_else(|error| panic!("{error:#?}")); let runtime = tokio::runtime::Builder::new_multi_thread() .worker_threads(2) @@ -470,7 +470,7 @@ fn measure_operation(operation: &Operation, shape: Shape, cap: u64) -> Result (usize, tempfile::TempDir) { - let compiled = - compile_script(src, "host_memory.subm", interpreter::FileId(0), &[], &[]).expect("compile"); + let compiled = compile_script( + src, + "host_memory.subm", + submilli_engine::FileId(0), + &[], + &[], + ) + .expect("compile"); let cfg = RuntimeConfig { memory_reservation: TEST_MEMORY_RESERVATION, ..RuntimeConfig::default() @@ -335,8 +341,8 @@ fn nightly_only_requested() -> bool { #[test] fn rejected_string_output_does_not_allocate_its_buffer() { - use interpreter::runtime::limits::{MemoryCapExceeded, TenantLimits}; - use interpreter::runtime::prelude::string::{Str, concat, pad_end, pad_start, repeat}; + use submilli_engine::runtime::limits::{MemoryCapExceeded, TenantLimits}; + use submilli_engine::runtime::prelude::string::{Str, concat, pad_end, pad_start, repeat}; if !nightly_only_requested() { eprintln!("host memory: skipped; set SUBMILLI_TEST_NIGHTLY_ONLY=1 to run"); diff --git a/crates/interpreter/tests/http_live.rs b/crates/interpreter/tests/http_live.rs index 033ab606b..40bbd3c30 100644 --- a/crates/interpreter/tests/http_live.rs +++ b/crates/interpreter/tests/http_live.rs @@ -5,7 +5,7 @@ use std::path::{Path, PathBuf}; use httpmock::Method::{HEAD, PATCH}; use httpmock::prelude::*; -use interpreter::{ +use submilli_engine::{ BacktraceMode, Diagnostic, RuntimeConfig, Sources, compile_script, diagnostics, render_backtrace, }; @@ -49,7 +49,7 @@ fn run_one(path: &Path, base: &str) -> Result<(), String> { let filename = rel(path); let src = raw.replace("{{BASE}}", base); - let compiled = compile_script(&src, &filename, interpreter::FileId(0), &[], &[]) + let compiled = compile_script(&src, &filename, submilli_engine::FileId(0), &[], &[]) .map_err(|diags| format!("compile failed:\n{}", render_diags(&diags, &filename, &src)))?; // `run` is async (and this fixture hits a real server via reqwest, so a tokio diff --git a/crates/interpreter/tests/lexer_limits.rs b/crates/interpreter/tests/lexer_limits.rs index 4070791cd..d5881457a 100644 --- a/crates/interpreter/tests/lexer_limits.rs +++ b/crates/interpreter/tests/lexer_limits.rs @@ -1,5 +1,5 @@ -use interpreter::FileId; -use interpreter::compile::compile_script_checked; +use submilli_engine::FileId; +use submilli_engine::compile::compile_script_checked; #[test] fn invalid_source_has_a_bounded_diagnostic_set_and_recovery_is_healthy() { diff --git a/crates/interpreter/tests/memory_caps.rs b/crates/interpreter/tests/memory_caps.rs index 720cb5eaa..31f9d49be 100644 --- a/crates/interpreter/tests/memory_caps.rs +++ b/crates/interpreter/tests/memory_caps.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use interpreter::{ +use submilli_engine::{ compile_script, dispatch_main_async, runtime::{ MemoryExhausted, RuntimeConfig, StoreData, Vfs, install_runtime_async, @@ -21,7 +21,7 @@ fn cap_run_with_host_bytes( src: &str, max_store_bytes: u64, ) -> wasmtime::Result<(wasmtime::Result<()>, u64)> { - let compiled = compile_script(src, "test.subm", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(src, "test.subm", submilli_engine::FileId(0), &[], &[]) .map_err(|d| wasmtime::Error::msg(format!("compile failed: {d:#?}")))?; // One engine may serve tenants with smaller caps than its own defaults. let cfg = RuntimeConfig::default(); @@ -236,7 +236,7 @@ function main(): void { let cfg = RuntimeConfig::default(); let compiled = - compile_script(src, "test.subm", interpreter::FileId(0), &[], &[]).expect("compile"); + compile_script(src, "test.subm", submilli_engine::FileId(0), &[], &[]).expect("compile"); let engine = cfg.engine().expect("engine"); let data = StoreData::with_vfs(Vfs::tempdir().expect("tempdir")); let mut store = cfg.store(&engine, data).expect("store"); @@ -377,8 +377,14 @@ function main(): void { } "#; - let compiled = compile_script(src, "memory_caps.subm", interpreter::FileId(0), &[], &[]) - .expect("compile clean"); + let compiled = compile_script( + src, + "memory_caps.subm", + submilli_engine::FileId(0), + &[], + &[], + ) + .expect("compile clean"); let cfg = RuntimeConfig { max_store_bytes: CAP_BYTES, ..RuntimeConfig::default() @@ -520,7 +526,7 @@ function main(): void { } "#; - let compiled = compile_script(src, "size_limit.subm", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(src, "size_limit.subm", submilli_engine::FileId(0), &[], &[]) .expect("compile clean"); let cfg = RuntimeConfig::default(); let engine = cfg.engine().expect("engine"); @@ -558,7 +564,7 @@ function main(): void { } "#; - let compiled = compile_script(src, "overwrite.subm", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(src, "overwrite.subm", submilli_engine::FileId(0), &[], &[]) .expect("compile clean"); let cfg = RuntimeConfig::default(); let engine = cfg.engine().expect("engine"); @@ -604,7 +610,7 @@ fn string_builders_refuse_native_output_and_refund_inputs() { assert!(err.is::(), "{expression}: {err:#}"); assert_eq!(host_bytes, 0, "{expression}: all native buffers refunded"); assert!( - err.is::(), + err.is::(), "{expression}: native admission refused before GC: {err:#}" ); } diff --git a/crates/interpreter/tests/namespace_limits.rs b/crates/interpreter/tests/namespace_limits.rs index 73cfe58d8..0d8722b3f 100644 --- a/crates/interpreter/tests/namespace_limits.rs +++ b/crates/interpreter/tests/namespace_limits.rs @@ -1,13 +1,13 @@ -use interpreter::compiler_limits::{ +use std::collections::BTreeMap; +use std::process::{Command, Stdio}; +use std::time::{Duration, Instant}; +use submilli_engine::compiler_limits::{ COMPILER_STACK_BYTES, MAX_NAMESPACE_DEPTH, MAX_NAMESPACE_NODES, MAX_NAMESPACE_PATH_BYTES, }; -use interpreter::type_size::TypeTooLarge; -use interpreter::{ +use submilli_engine::type_size::TypeTooLarge; +use submilli_engine::{ FileId, ModulePath, NamespaceSymbol, PackageDeclaration, PackageSourceModule, Span, }; -use std::collections::BTreeMap; -use std::process::{Command, Stdio}; -use std::time::{Duration, Instant}; #[test] fn namespace_limits_and_cleanup() { @@ -46,7 +46,7 @@ fn namespace_limits_and_cleanup() { fn namespace() -> NamespaceSymbol { NamespaceSymbol { name: "N".into(), - mangled_prefix: interpreter::mangle::prelude("N"), + mangled_prefix: submilli_engine::mangle::prelude("N"), declaration_span: Span::at(FileId(0)), values: BTreeMap::new(), types: BTreeMap::new(), @@ -109,7 +109,7 @@ fn check_namespace_limits() { }]; let very_deep = declaration(30_000); assert!( - interpreter::compile::compile_package_with_transitive_checked( + submilli_engine::compile::compile_package_with_transitive_checked( "pkg", ModulePath::from("lib"), &modules, @@ -119,7 +119,7 @@ fn check_namespace_limits() { .is_err() ); assert!( - interpreter::compile::compile_package_with_transitive_checked( + submilli_engine::compile::compile_package_with_transitive_checked( "pkg", ModulePath::from("lib"), &modules, @@ -134,7 +134,7 @@ fn check_namespace_limits() { let source = "export function main(): number { return 1; }"; let deep = declaration(MAX_NAMESPACE_DEPTH + 1); assert!( - interpreter::compile::compile_script_checked( + submilli_engine::compile::compile_script_checked( source, "main.ts", FileId(0), @@ -145,7 +145,7 @@ fn check_namespace_limits() { ); let healthy = declaration(2); assert!( - interpreter::compile::compile_script_checked( + submilli_engine::compile::compile_script_checked( source, "main.ts", FileId(0), diff --git a/crates/interpreter/tests/object_vtable_dispatch.rs b/crates/interpreter/tests/object_vtable_dispatch.rs index 94accf779..bb503fd70 100644 --- a/crates/interpreter/tests/object_vtable_dispatch.rs +++ b/crates/interpreter/tests/object_vtable_dispatch.rs @@ -8,7 +8,7 @@ use wasm_encoder::{ }; use wasmtime::{Linker, Module as WtModule}; -use interpreter::RuntimeConfig; +use submilli_engine::RuntimeConfig; // Outside the rec group: const STRING_IDX: u32 = 0; diff --git a/crates/interpreter/tests/package_diagnostic_snapshots.rs b/crates/interpreter/tests/package_diagnostic_snapshots.rs index 9654425bc..cc4406ad2 100644 --- a/crates/interpreter/tests/package_diagnostic_snapshots.rs +++ b/crates/interpreter/tests/package_diagnostic_snapshots.rs @@ -5,7 +5,7 @@ use std::collections::BTreeMap; -use interpreter::{ +use submilli_engine::{ Asi, FileId, ModulePath, PackageDeclaration, Sources, Token, TokenKind, diagnostics, infer_package, lower_patterns, parse, }; @@ -45,7 +45,7 @@ fn render_package(body: &str) -> String { out } -fn parse_source(source: &str, file: FileId) -> interpreter::Ast { +fn parse_source(source: &str, file: FileId) -> submilli_engine::Ast { let mut asi = Asi::new(source, file); let mut tokens: Vec = Vec::new(); loop { @@ -64,12 +64,13 @@ fn parse_source(source: &str, file: FileId) -> interpreter::Ast { } fn runtime_declarations() -> BTreeMap { - let (prelude, host, _) = interpreter::runtime::prelude::cached_runtime_package_declarations(); + let (prelude, host, _) = + submilli_engine::runtime::prelude::cached_runtime_package_declarations(); prelude .iter() .chain(host) .cloned() - .chain(interpreter::stdlib::stdlib_package_declarations()) + .chain(submilli_engine::stdlib::stdlib_package_declarations()) .map(|declaration| (declaration.package_name.clone(), declaration)) .collect() } diff --git a/crates/interpreter/tests/parser_depth.rs b/crates/interpreter/tests/parser_depth.rs index f033ed0ba..0fe9a75a6 100644 --- a/crates/interpreter/tests/parser_depth.rs +++ b/crates/interpreter/tests/parser_depth.rs @@ -2,7 +2,7 @@ use std::process::Command; use std::time::{Duration, Instant}; -use interpreter::{Asi, FileId, TokenKind, parse, parse_script}; +use submilli_engine::{Asi, FileId, TokenKind, parse, parse_script}; #[test] fn parser_depth_is_bounded() { diff --git a/crates/interpreter/tests/record_limits.rs b/crates/interpreter/tests/record_limits.rs index f4f81ac60..010c7685b 100644 --- a/crates/interpreter/tests/record_limits.rs +++ b/crates/interpreter/tests/record_limits.rs @@ -44,10 +44,10 @@ fn check_alias_limits() { source.push_str(&format!("type Alias{index} = Alias{};\n", index + 1)); } source.push_str(&format!("type Alias{depth} = ZBase;\ninterface ZBase {{ [key: string]: number; }}\nfunction main(): void {{}}")); - let result = interpreter::compile_script( + let result = submilli_engine::compile_script( &source, "record-limit.ts", - interpreter::FileId(0), + submilli_engine::FileId(0), &[], &[], ); @@ -62,10 +62,10 @@ fn check_alias_limits() { "{diagnostics:?}" ); } - interpreter::compile_script( + submilli_engine::compile_script( "function main(): number { return 42; }", "healthy.ts", - interpreter::FileId(0), + submilli_engine::FileId(0), &[], &[], ) diff --git a/crates/interpreter/tests/substitution_limits.rs b/crates/interpreter/tests/substitution_limits.rs index cf8173918..208ff2bc3 100644 --- a/crates/interpreter/tests/substitution_limits.rs +++ b/crates/interpreter/tests/substitution_limits.rs @@ -1,8 +1,8 @@ -use interpreter::Type; -use interpreter::type_size::{TypeLimits, TypeTooLarge}; -use interpreter::typechecker::type_param_substitution::TypeParamSubstitution; use std::process::{Command, Stdio}; use std::time::{Duration, Instant}; +use submilli_engine::Type; +use submilli_engine::type_size::{TypeLimits, TypeTooLarge}; +use submilli_engine::typechecker::type_param_substitution::TypeParamSubstitution; #[test] fn binding_chains_on_small_stack() { diff --git a/crates/interpreter/tests/traps_in_callbacks.rs b/crates/interpreter/tests/traps_in_callbacks.rs index 447cd715c..9b0db57e9 100644 --- a/crates/interpreter/tests/traps_in_callbacks.rs +++ b/crates/interpreter/tests/traps_in_callbacks.rs @@ -4,7 +4,7 @@ use std::time::Duration; -use interpreter::{compile_script, runtime::RuntimeConfig}; +use submilli_engine::{compile_script, runtime::RuntimeConfig}; use wasmtime::{Trap, WasmBacktrace}; /// Every program below returns normally from its handler, so a run that reaches @@ -12,7 +12,7 @@ use wasmtime::{Trap, WasmBacktrace}; fn run(raise: &str, body: &str, cfg: RuntimeConfig) -> wasmtime::Result<()> { let source = format!("{PRELUDE}\nfunction main(): string {{\n{body}\n}}\n").replace("RAISE", raise); - let compiled = compile_script(&source, "test.ts", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(&source, "test.ts", submilli_engine::FileId(0), &[], &[]) .map_err(|diagnostics| wasmtime::Error::msg(format!("compile failed: {diagnostics:#?}")))?; // Re-entry nests interpreter frames on the native stack, so the thread is // sized for the config as the CLI and the server size theirs. @@ -162,7 +162,7 @@ fn a_timeout_under_a_callback_is_not_catchable() { #[test] fn a_timeout_in_top_level_statements_ends_the_run() { let source = "let spins = 0;\nwhile (true) { spins = spins + 1; }\nfunction main(): void { }\n"; - let compiled = compile_script(source, "test.ts", interpreter::FileId(0), &[], &[]) + let compiled = compile_script(source, "test.ts", submilli_engine::FileId(0), &[], &[]) .unwrap_or_else(|diagnostics| panic!("compile failed: {diagnostics:#?}")); let cfg = RuntimeConfig { fuel: u64::MAX, diff --git a/crates/interpreter/tests/type_limits.rs b/crates/interpreter/tests/type_limits.rs index 77756ba70..43a187bf7 100644 --- a/crates/interpreter/tests/type_limits.rs +++ b/crates/interpreter/tests/type_limits.rs @@ -4,10 +4,12 @@ //! //! Set `SUBMILLI_TEST_NIGHTLY_ONLY=1` to run these limit-sized inputs. //! `SUBMILLI_FULL_TEST` does not enable them. -use interpreter::compile::{PackageSourceModule, compile_package_checked, compile_script_checked}; -use interpreter::compiler_error::{CompilerFailure, CompilerStage}; -use interpreter::compiler_limits::{COMPILER_STACK_BYTES, MAX_TYPE_DEPTH}; -use interpreter::{FileId, ModulePath, PackageDeclaration, Span, Type, ValueKind, ValueSymbol}; +use submilli_engine::compile::{ + PackageSourceModule, compile_package_checked, compile_script_checked, +}; +use submilli_engine::compiler_error::{CompilerFailure, CompilerStage}; +use submilli_engine::compiler_limits::{COMPILER_STACK_BYTES, MAX_TYPE_DEPTH}; +use submilli_engine::{FileId, ModulePath, PackageDeclaration, Span, Type, ValueKind, ValueSymbol}; const SCRIPT: &str = "export function main(): number { return 1; }"; @@ -21,7 +23,7 @@ fn declaring(ty: Type) -> PackageDeclaration { "value".into(), ValueSymbol { name: "value".into(), - mangled_name: interpreter::mangle::package_symbol("dep", "value"), + mangled_name: submilli_engine::mangle::package_symbol("dep", "value"), declaration_span: Span::at(FileId(0)), kind: ValueKind::Const { ty, doc: None }, }, @@ -263,7 +265,7 @@ fn comparing_types_draws_on_the_work_limit() { message, format!( "building and comparing types takes more than the compiler limit of {} steps", - interpreter::compiler_limits::MAX_TYPE_WORK + submilli_engine::compiler_limits::MAX_TYPE_WORK ) ); } @@ -319,7 +321,7 @@ fn a_runtime_check_too_large_for_one_function_is_reported_at_the_cast() { message, format!( "the runtime check of `I | null` makes its function larger than the {} bytes a function may have", - interpreter::compiler_limits::MAX_FUNCTION_BODY_BYTES + submilli_engine::compiler_limits::MAX_FUNCTION_BODY_BYTES ) ); assert_eq!(text, "JSON.parse(\"null\") as I | null"); @@ -330,7 +332,7 @@ fn a_function_with_too_many_locals_is_reported_where_it_runs_out() { if !nightly_only_requested() { return; } - let locals = interpreter::compiler_limits::MAX_FUNCTION_LOCALS + 10; + let locals = submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS + 10; let body: String = (0..locals) .map(|i| format!(" const v{i} = {i};\n")) .collect(); @@ -340,14 +342,14 @@ fn a_function_with_too_many_locals_is_reported_where_it_runs_out() { message, format!( "the function this code compiles into needs more than the {} locals a function may have", - interpreter::compiler_limits::MAX_FUNCTION_LOCALS + submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS ) ); // The initializer of the binding whose local crosses the limit, not the // whole body. assert_eq!( text, - interpreter::compiler_limits::MAX_FUNCTION_LOCALS.to_string() + submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS.to_string() ); } @@ -357,7 +359,7 @@ fn a_function_with_too_many_locals_is_reported_where_it_runs_out() { fn function_whose_loop_crosses_the_locals_limit(name: &str) -> String { // Seven locals short of the limit leaves `arr` and `s` within it, so the // loop's own locals cross it. - let consts = interpreter::compiler_limits::MAX_FUNCTION_LOCALS - 7; + let consts = submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS - 7; let body: String = (0..consts) .map(|i| format!(" const v{i} = {i};\n")) .collect(); @@ -384,7 +386,7 @@ fn a_check_after_code_that_crossed_the_locals_limit_does_not_take_the_blame() { if !nightly_only_requested() { return; } - let locals = interpreter::compiler_limits::MAX_FUNCTION_LOCALS + 10; + let locals = submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS + 10; let body: String = (0..locals) .map(|i| format!(" const v{i} = {i};\n")) .collect(); @@ -397,12 +399,12 @@ fn a_check_after_code_that_crossed_the_locals_limit_does_not_take_the_blame() { message, format!( "the function this code compiles into needs more than the {} locals a function may have", - interpreter::compiler_limits::MAX_FUNCTION_LOCALS + submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS ) ); assert_eq!( text, - interpreter::compiler_limits::MAX_FUNCTION_LOCALS.to_string() + submilli_engine::compiler_limits::MAX_FUNCTION_LOCALS.to_string() ); } diff --git a/crates/interpreter/tests/vfs_containment.rs b/crates/interpreter/tests/vfs_containment.rs index c23599c68..1a9abc12b 100644 --- a/crates/interpreter/tests/vfs_containment.rs +++ b/crates/interpreter/tests/vfs_containment.rs @@ -26,10 +26,10 @@ use std::path::{Path, PathBuf}; -use interpreter::runtime::{ +use submilli_engine::runtime::{ RuntimeConfig, StoreData, Vfs, install_runtime_async, install_tenant_limits, }; -use interpreter::{FileId, compile_script, dispatch_main_async}; +use submilli_engine::{FileId, compile_script, dispatch_main_async}; use wasmtime::{Linker, Module}; const ESCAPE_DIAGNOSTIC: &str = "path escapes the VFS root"; diff --git a/crates/submilli-build/Cargo.toml b/crates/submilli-build/Cargo.toml index 199f58b72..1d710a416 100644 --- a/crates/submilli-build/Cargo.toml +++ b/crates/submilli-build/Cargo.toml @@ -10,7 +10,7 @@ publish.workspace = true workspace = true [dependencies] -interpreter = { path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } diff --git a/crates/submilli-policy/Cargo.toml b/crates/submilli-policy/Cargo.toml index f57062290..33c3e31fb 100644 --- a/crates/submilli-policy/Cargo.toml +++ b/crates/submilli-policy/Cargo.toml @@ -1,10 +1,14 @@ [package] name = "submilli-policy" +description = "The Submilli policy engine: permission rules and their filter language, session variables, and auth-proxy injection" version.workspace = true edition.workspace = true license.workspace = true repository.workspace = true -publish.workspace = true +readme = "README.md" +keywords = ["submilli", "policy", "permissions", "agents"] +categories = ["config"] +publish = true [lints] workspace = true @@ -18,13 +22,13 @@ serde_json = { workspace = true } regex = { workspace = true } async-trait = { workspace = true } base64 = { workspace = true } -interpreter = { path = "../interpreter", optional = true } +submilli-engine = { version = "0.3.0", path = "../interpreter", optional = true } url = { workspace = true, optional = true } [features] # Adapters from the policy types to the engine's host-service traits. -engine = ["dep:interpreter", "dep:url"] +engine = ["dep:submilli-engine", "dep:url"] [dev-dependencies] -interpreter = { path = "../interpreter" } +submilli-engine = { path = "../interpreter" } tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/crates/submilli-policy/README.md b/crates/submilli-policy/README.md new file mode 100644 index 000000000..f1015729a --- /dev/null +++ b/crates/submilli-policy/README.md @@ -0,0 +1,15 @@ +# submilli-policy + +The policy engine of [Submilli](https://github.com/submilli/submilli-runtime): +per-caller permission rules and their filter language, session variables, and +auth-proxy injection of secrets into outbound HTTP. + +The types are format-neutral. A Submilli blueprint file is one way to write a +policy; an embedder that keeps policy elsewhere builds a `Policy` and an +`AuthProxyPolicy` from its own format and evaluates them the same way. + +With the `engine` feature, `submilli_policy::host` adapts them to +[`submilli-engine`](https://crates.io/crates/submilli-engine)'s host-service +traits: `PolicyCheck`, `PolicyAuthProxy` and `PolicySecretProvider`. + +Licensed under Apache-2.0. diff --git a/crates/submilli-policy/src/host.rs b/crates/submilli-policy/src/host.rs index 5f3ab1020..6f2b23e5c 100644 --- a/crates/submilli-policy/src/host.rs +++ b/crates/submilli-policy/src/host.rs @@ -8,12 +8,12 @@ use std::collections::BTreeMap; use std::sync::Arc; use async_trait::async_trait; -use interpreter::runtime::{ +use submilli_engine::runtime::{ AuthProxy, AuthProxyError, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, FailureReasonRecord, FailureRecord, HttpRequest, NearMissRecord, RuleCitation, SecretProvider, SecurityCheck, }; -use interpreter::stdlib::http::HttpTransportPolicy; +use submilli_engine::stdlib::http::HttpTransportPolicy; use url::Url; use crate::{ @@ -231,7 +231,7 @@ fn filesystem_policy_context<'a>( .ok_or_else(|| { format!("invalid {capability} context: {field} must be a VFS path string") })?; - let normalized = interpreter::runtime::fs::guest_normalize(cwd, path) + let normalized = submilli_engine::runtime::fs::guest_normalize(cwd, path) .map_err(|error| format!("invalid {capability} {field}: {error}"))?; if normalized != path { normalized_context.to_mut()[field] = serde_json::Value::String(normalized); @@ -448,7 +448,7 @@ mod tests { #[test] fn normalized_policy_paths_are_vfs_path_fields_in_the_catalog() { - use interpreter::stdlib::capabilities::{FieldNormalization, catalog}; + use submilli_engine::stdlib::capabilities::{FieldNormalization, catalog}; for capability in catalog().iter().flat_map(|group| group.capabilities) { for field in filesystem_path_fields(capability.name) { let normalization = capability diff --git a/crates/submilli-policy/tests/engine_literal_parity.rs b/crates/submilli-policy/tests/engine_literal_parity.rs index 5540b3842..a2da63821 100644 --- a/crates/submilli-policy/tests/engine_literal_parity.rs +++ b/crates/submilli-policy/tests/engine_literal_parity.rs @@ -4,9 +4,9 @@ //! field name the engine's capability catalog offers can be written in a //! filter. -use interpreter::capability_derivation::filter_string_literal; -use interpreter::stdlib::capabilities; -use interpreter::{OptionalPackage, Stdlib}; +use submilli_engine::capability_derivation::filter_string_literal; +use submilli_engine::stdlib::capabilities; +use submilli_engine::{OptionalPackage, Stdlib}; use submilli_policy::filter_syntax::{is_field_name, parse, quote_literal}; const CORPUS: &[&str] = &[ diff --git a/crates/submilli-server/Cargo.toml b/crates/submilli-server/Cargo.toml index 2742ee4e3..fb5c52b12 100644 --- a/crates/submilli-server/Cargo.toml +++ b/crates/submilli-server/Cargo.toml @@ -17,7 +17,7 @@ path = "src/main.rs" path = "src/lib.rs" [dependencies] -interpreter = { path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } diff --git a/crates/submilli-shared/Cargo.toml b/crates/submilli-shared/Cargo.toml index a1f84de7a..cca220dac 100644 --- a/crates/submilli-shared/Cargo.toml +++ b/crates/submilli-shared/Cargo.toml @@ -13,7 +13,7 @@ workspace = true path = "src/lib.rs" [dependencies] -interpreter = { path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-policy = { path = "../submilli-policy", features = ["engine"] } submilli-build = { path = "../submilli-build" } diff --git a/crates/submilli/Cargo.toml b/crates/submilli/Cargo.toml index 5db918b2c..1a0937d16 100644 --- a/crates/submilli/Cargo.toml +++ b/crates/submilli/Cargo.toml @@ -14,7 +14,7 @@ name = "submilli" path = "src/main.rs" [dependencies] -interpreter = { path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } From 4c1ccf3f6e6d83369529258ced96cf7f52b920d8 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 18:49:29 +0300 Subject: [PATCH 06/10] Harden harness package inputs and tidy the new engine surface Skill names are checked like paths before a provider sees them (one segment; `:` allowed for namespaced names), providers must match names byte for byte, and `load` refuses a skill answered under another name. Refusals before dispatch are recorded as the call's error, echoed input is truncated, and list() offers only loadable names. The typed agents.run documents SyntaxError for a non-JSON answer. Set-taking APIs share one `_for` suffix, the typechecker's schema-checked path loses its llm-only names, and the free policy functions are hidden behind the Policy methods. Co-Authored-By: Claude Opus 5.5 --- crates/interpreter/src/compile.rs | 4 +- crates/interpreter/src/packages.rs | 342 +++++++++--------- crates/interpreter/src/runtime/agents.rs | 17 +- crates/interpreter/src/runtime/skills.rs | 56 ++- .../src/stdlib/agents/declaration.rs | 4 +- crates/interpreter/src/stdlib/agents/mod.rs | 69 ++-- crates/interpreter/src/stdlib/capabilities.rs | 10 +- crates/interpreter/src/stdlib/mod.rs | 56 +-- .../interpreter/src/stdlib/optional_tests.rs | 302 +++++++++++++++- crates/interpreter/src/stdlib/shared.rs | 32 ++ .../src/stdlib/skills/declaration.rs | 17 +- crates/interpreter/src/stdlib/skills/mod.rs | 232 +++++++++--- .../interpreter/src/typechecker/infer/expr.rs | 40 +- .../src/typechecker/infer/generic.rs | 41 ++- crates/submilli-blueprint/src/auth_proxy.rs | 11 +- crates/submilli-policy/src/lib.rs | 6 +- crates/submilli-policy/src/permissions.rs | 10 +- crates/submilli-shared/src/host.rs | 3 +- docs/part-6-reference/standard-library.md | 23 +- plans/sub-1269-host-fuel-costs.md | 4 +- 20 files changed, 897 insertions(+), 382 deletions(-) diff --git a/crates/interpreter/src/compile.rs b/crates/interpreter/src/compile.rs index 30abed2f7..ac99c0cdc 100644 --- a/crates/interpreter/src/compile.rs +++ b/crates/interpreter/src/compile.rs @@ -528,7 +528,7 @@ pub fn compile_package_with_transitive_checked( dependencies: &[&PackageDeclaration], transitive: &[&PackageDeclaration], ) -> Result { - compile_package_with_transitive_in_checked( + compile_package_with_transitive_checked_for( Stdlib::core(), package_name, root_module, @@ -540,7 +540,7 @@ pub fn compile_package_with_transitive_checked( /// [`compile_package_with_transitive_checked`] for an embedder that offers /// `stdlib`, so the package may import its optional packages. -pub fn compile_package_with_transitive_in_checked( +pub fn compile_package_with_transitive_checked_for( stdlib: Stdlib, package_name: &str, root_module: ModulePath, diff --git a/crates/interpreter/src/packages.rs b/crates/interpreter/src/packages.rs index 8e94e3f5d..e633f0644 100644 --- a/crates/interpreter/src/packages.rs +++ b/crates/interpreter/src/packages.rs @@ -50,6 +50,8 @@ pub fn search(query: &str) -> Vec { Stdlib::core().search(query) } +/// Discovery over the modules of a [`Stdlib`]: what the free functions above do +/// for [`Stdlib::core`], for any set. impl Stdlib { /// [`docs`] over the modules of this set. pub fn docs(self, name: &str) -> Option { @@ -75,6 +77,163 @@ impl Stdlib { }) .collect() } + + /// [`resolve`] over the modules of this set. + pub fn resolve(self, name: &str) -> Resolution { + if let Some(doc) = self.docs(name) { + return Resolution::Module(doc); + } + match builtin_lookup(name) { + BuiltinLookup::Found(declarations) => Resolution::Builtin { + name: name.to_string(), + declarations, + }, + BuiltinLookup::UnknownMember { + path, + member, + members, + } => Resolution::UnknownMember { + path, + member, + members, + }, + BuiltinLookup::Unknown => Resolution::Unknown, + } + } + + /// [`suggest_filtered`] over the modules of this set. + pub fn suggest_filtered( + self, + name: &str, + extra: &[String], + visible: impl Fn(&str) -> bool, + ) -> Option { + let mut candidates: Vec = self.search("").into_iter().map(|m| m.name).collect(); + let builtins = builtins(); + candidates.extend(builtins.types); + candidates.extend(builtins.namespaces); + candidates.extend(extra.iter().cloned()); + candidates.retain(|candidate| visible(candidate)); + + // Only the head segment is in question: `Temporel.Instant` misses because + // of `Temporel`, and the tail only inflates the distance past threshold. + let query = name.split('.').find(|s| !s.is_empty()).unwrap_or(name); + // `closest_match` floors its threshold at 2 edits, so a one- or two-character + // query sits within reach of an unrelated name. Below that length there is no + // signal to match on. + if query.len() < 3 { + return None; + } + + if let Some((_, replacement)) = OMITTED_GLOBALS + .iter() + .find(|(omitted, _)| omitted.eq_ignore_ascii_case(name)) + { + return Some((*replacement).to_string()); + } + + // Never offer the query back to the caller: a name that resolved nowhere is + // not its own repair, however it was spelled. + let is_self = |c: &String| c.eq_ignore_ascii_case(name); + if let Some(hit) = candidates + .iter() + .find(|c| !is_self(c) && name_tail(c).eq_ignore_ascii_case(query)) + { + return Some(hit.clone()); + } + // Match full names and scheme-stripped tails in one pass, so the globally + // closest key wins: `htp` should reach `submilli:http` (one edit from its + // tail) rather than whichever unrelated full name lands inside threshold. + let mut keys: Vec<(&str, &str)> = Vec::new(); + for c in candidates.iter().filter(|c| !is_self(c)) { + keys.push((c.as_str(), c.as_str())); + let tail = name_tail(c); + if tail != c.as_str() { + keys.push((tail, c.as_str())); + } + } + let hit = crate::did_you_mean::closest_match(query, keys.iter().map(|(k, _)| *k))?; + keys.iter() + .find(|(k, _)| *k == hit) + .map(|(_, owner)| (*owner).to_string()) + } + + /// [`catalog_filtered`] over the modules of this set. + pub fn catalog_filtered( + self, + extra: Vec, + visible: impl Fn(&str) -> bool, + ) -> Catalog { + let mut entries: Vec = self + .search("") + .into_iter() + .map(|m| CatalogEntry { + name: m.name, + source: SOURCE_STDLIB.to_string(), + description: m.description, + }) + .collect(); + entries.extend(extra); + entries.retain(|entry| visible(&entry.name)); + let remaining = entries.len().saturating_sub(CATALOG_LIMIT); + entries.truncate(CATALOG_LIMIT); + Catalog { entries, remaining } + } + + /// [`render_stdlib_d_ts`] for the modules of this set. + pub fn render_stdlib_d_ts(self) -> String { + let mut out = String::new(); + for defs in &editor_stdlib_modules(self) { + render_declare_module(&mut out, defs); + } + out.trim_end().to_string() + } + + /// [`render_packages_d_ts`] against the modules of this set. + pub fn render_packages_d_ts( + self, + packages: &[&PackageDeclaration], + context: &[&PackageDeclaration], + ) -> String { + let stdlib = editor_stdlib_modules(self); + let exporters = TypeExporters::new( + stdlib + .iter() + .chain(packages.iter().copied()) + .chain(context.iter().copied()), + ); + let globals = global_classes(); + let mut out = String::new(); + for defs in packages { + let _ = writeln!(out, "declare module \"{}\" {{", defs.package_name); + let imports = block_imports(defs, &exporters); + for (local, (public, module)) in &imports.types { + if local == public { + let _ = writeln!(out, " import type {{ {local} }} from \"{module}\";"); + } else { + let _ = writeln!( + out, + " import type {{ {public} as {local} }} from \"{module}\";" + ); + } + } + let parent = |extends: &ClassExtends| { + if let Some(local) = imports.parents.get(extends.parent.as_str()) { + return Some(ts_named_type(local, &extends.args)); + } + // A package value of the global's name would hide it; the class + // then renders without its parent rather than extend the value. + let global = globals.get(extends.parent.as_str())?; + if declares(defs, global, true) { + return None; + } + Some(ts_named_type(global, &extends.args)) + }; + render_ts_declarations(&mut out, defs, " ", "export ", &parent); + let _ = writeln!(out, "}}\n"); + } + out.trim_end().to_string() + } } /// The language built-ins always in scope without an `import`: headline prelude @@ -563,31 +722,6 @@ pub fn resolve(name: &str) -> Resolution { Stdlib::core().resolve(name) } -impl Stdlib { - /// [`resolve`] over the modules of this set. - pub fn resolve(self, name: &str) -> Resolution { - if let Some(doc) = self.docs(name) { - return Resolution::Module(doc); - } - match builtin_lookup(name) { - BuiltinLookup::Found(declarations) => Resolution::Builtin { - name: name.to_string(), - declarations, - }, - BuiltinLookup::UnknownMember { - path, - member, - members, - } => Resolution::UnknownMember { - path, - member, - members, - }, - BuiltinLookup::Unknown => Resolution::Unknown, - } - } -} - /// A did-you-mean candidate for a name that resolved nowhere, drawn from the /// stdlib and built-in catalogs plus any `extra` names the caller can see /// (`@mcp/*`, registry packages). @@ -614,65 +748,6 @@ pub fn suggest_filtered( Stdlib::core().suggest_filtered(name, extra, visible) } -impl Stdlib { - /// [`suggest_filtered`] over the modules of this set. - pub fn suggest_filtered( - self, - name: &str, - extra: &[String], - visible: impl Fn(&str) -> bool, - ) -> Option { - let mut candidates: Vec = self.search("").into_iter().map(|m| m.name).collect(); - let builtins = builtins(); - candidates.extend(builtins.types); - candidates.extend(builtins.namespaces); - candidates.extend(extra.iter().cloned()); - candidates.retain(|candidate| visible(candidate)); - - // Only the head segment is in question: `Temporel.Instant` misses because - // of `Temporel`, and the tail only inflates the distance past threshold. - let query = name.split('.').find(|s| !s.is_empty()).unwrap_or(name); - // `closest_match` floors its threshold at 2 edits, so a one- or two-character - // query sits within reach of an unrelated name. Below that length there is no - // signal to match on. - if query.len() < 3 { - return None; - } - - if let Some((_, replacement)) = OMITTED_GLOBALS - .iter() - .find(|(omitted, _)| omitted.eq_ignore_ascii_case(name)) - { - return Some((*replacement).to_string()); - } - - // Never offer the query back to the caller: a name that resolved nowhere is - // not its own repair, however it was spelled. - let is_self = |c: &String| c.eq_ignore_ascii_case(name); - if let Some(hit) = candidates - .iter() - .find(|c| !is_self(c) && name_tail(c).eq_ignore_ascii_case(query)) - { - return Some(hit.clone()); - } - // Match full names and scheme-stripped tails in one pass, so the globally - // closest key wins: `htp` should reach `submilli:http` (one edit from its - // tail) rather than whichever unrelated full name lands inside threshold. - let mut keys: Vec<(&str, &str)> = Vec::new(); - for c in candidates.iter().filter(|c| !is_self(c)) { - keys.push((c.as_str(), c.as_str())); - let tail = name_tail(c); - if tail != c.as_str() { - keys.push((tail, c.as_str())); - } - } - let hit = crate::did_you_mean::closest_match(query, keys.iter().map(|(k, _)| *k))?; - keys.iter() - .find(|(k, _)| *k == hit) - .map(|(_, owner)| (*owner).to_string()) - } -} - /// The part of a package name after its scheme or scope: `submilli:http` and /// `@mcp/linear` reduce to `http` and `linear`. fn name_tail(name: &str) -> &str { @@ -743,30 +818,6 @@ pub fn catalog_filtered(extra: Vec, visible: impl Fn(&str) -> bool Stdlib::core().catalog_filtered(extra, visible) } -impl Stdlib { - /// [`catalog_filtered`] over the modules of this set. - pub fn catalog_filtered( - self, - extra: Vec, - visible: impl Fn(&str) -> bool, - ) -> Catalog { - let mut entries: Vec = self - .search("") - .into_iter() - .map(|m| CatalogEntry { - name: m.name, - source: SOURCE_STDLIB.to_string(), - description: m.description, - }) - .collect(); - entries.extend(extra); - entries.retain(|entry| visible(&entry.name)); - let remaining = entries.len().saturating_sub(CATALOG_LIMIT); - entries.truncate(CATALOG_LIMIT); - Catalog { entries, remaining } - } -} - /// Name the head, then list what it actually has, so the repair is one edit. pub fn unknown_member_message(path: &str, member: &str, members: &[String]) -> String { if members.is_empty() { @@ -902,17 +953,6 @@ pub fn render_stdlib_d_ts() -> String { Stdlib::core().render_stdlib_d_ts() } -impl Stdlib { - /// [`render_stdlib_d_ts`] for the modules of this set. - pub fn render_stdlib_d_ts(self) -> String { - let mut out = String::new(); - for defs in &editor_stdlib_modules(self) { - render_declare_module(&mut out, defs); - } - out.trim_end().to_string() - } -} - /// Render editor-facing TypeScript declarations for `packages`, one /// `declare module` block each, in the order given. /// @@ -929,54 +969,6 @@ pub fn render_packages_d_ts( Stdlib::core().render_packages_d_ts(packages, context) } -impl Stdlib { - /// [`render_packages_d_ts`] against the modules of this set. - pub fn render_packages_d_ts( - self, - packages: &[&PackageDeclaration], - context: &[&PackageDeclaration], - ) -> String { - let stdlib = editor_stdlib_modules(self); - let exporters = TypeExporters::new( - stdlib - .iter() - .chain(packages.iter().copied()) - .chain(context.iter().copied()), - ); - let globals = global_classes(); - let mut out = String::new(); - for defs in packages { - let _ = writeln!(out, "declare module \"{}\" {{", defs.package_name); - let imports = block_imports(defs, &exporters); - for (local, (public, module)) in &imports.types { - if local == public { - let _ = writeln!(out, " import type {{ {local} }} from \"{module}\";"); - } else { - let _ = writeln!( - out, - " import type {{ {public} as {local} }} from \"{module}\";" - ); - } - } - let parent = |extends: &ClassExtends| { - if let Some(local) = imports.parents.get(extends.parent.as_str()) { - return Some(ts_named_type(local, &extends.args)); - } - // A package value of the global's name would hide it; the class - // then renders without its parent rather than extend the value. - let global = globals.get(extends.parent.as_str())?; - if declares(defs, global, true) { - return None; - } - Some(ts_named_type(global, &extends.args)) - }; - render_ts_declarations(&mut out, defs, " ", "export ", &parent); - let _ = writeln!(out, "}}\n"); - } - out.trim_end().to_string() - } -} - /// The built-in classes a package's class may extend, such as `Error`, by /// mangled name. They're globals, so a parent among them needs no import. fn global_classes() -> BTreeMap { @@ -2812,9 +2804,17 @@ mod tests { assert!(builtin_no_import_note("Temporal").contains("import")); } + /// Every package any embedder can enable, so the declaration checks below + /// cover the optional packages too. + fn every_package() -> Stdlib { + crate::stdlib::OptionalPackage::ALL + .iter() + .fold(Stdlib::core(), |set, package| set.with(*package)) + } + #[test] fn stdlib_capability_tags_parse_cleanly() { - for module in user_modules(Stdlib::core()) { + for module in user_modules(every_package()) { for symbol in module.values.values() { let Some(doc) = value_doc(&symbol.kind) else { continue; @@ -2834,7 +2834,7 @@ mod tests { #[test] fn every_importable_stdlib_symbol_has_docs() { - for module in user_modules(Stdlib::core()) { + for module in user_modules(every_package()) { for symbol in module.values.values() { assert!( value_doc(&symbol.kind).is_some(), @@ -3414,8 +3414,8 @@ mod tests { #[test] fn stdlib_d_ts_declares_each_user_module() { - let docs = render_stdlib_d_ts(); - for module in user_modules(Stdlib::core()) { + let docs = every_package().render_stdlib_d_ts(); + for module in user_modules(every_package()) { assert!( docs.contains(&format!("declare module \"{}\" {{", module.package_name)), "missing declare module for {}", diff --git a/crates/interpreter/src/runtime/agents.rs b/crates/interpreter/src/runtime/agents.rs index 2ca98e4d9..52fb9c50d 100644 --- a/crates/interpreter/src/runtime/agents.rs +++ b/crates/interpreter/src/runtime/agents.rs @@ -18,12 +18,18 @@ use std::pin::Pin; use serde::{Deserialize, Serialize}; +use crate::stdlib::shared::truncated; + pub const AGENTS_MODULE_NAME: &str = "submilli:agents"; /// One sub-agent run, as the program asked for it. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct AgentRequest { - /// The agent's name, as [`AgentProvider::agents`] lists it. + /// The agent's name, exactly as the program wrote it. Not checked against + /// [`AgentProvider::agents`]: an unknown name is the provider's + /// [`AgentCallError::NotFound`]. The policy decided on it as written, so a + /// provider must match it byte for byte — no case folding, Unicode + /// normalization or path canonicalization — and must not use it as a path. pub agent: String, /// The task for the agent. pub input: String, @@ -86,10 +92,13 @@ impl std::fmt::Display for AgentCallError { ), Self::NotFound { agent } => write!( f, - "no agent named `{agent}`; call `list()` for the agents you may use" + "no agent named `{}`; call `list()` for the agents you may use", + truncated(agent) ), - Self::Failed { agent, message } => write!(f, "agent `{agent}` failed: {message}"), - Self::Cancelled { agent } => write!(f, "agent `{agent}` was cancelled"), + Self::Failed { agent, message } => { + write!(f, "agent `{}` failed: {message}", truncated(agent)) + } + Self::Cancelled { agent } => write!(f, "agent `{}` was cancelled", truncated(agent)), } } } diff --git a/crates/interpreter/src/runtime/skills.rs b/crates/interpreter/src/runtime/skills.rs index c1b72f6f2..b93bd0029 100644 --- a/crates/interpreter/src/runtime/skills.rs +++ b/crates/interpreter/src/runtime/skills.rs @@ -10,6 +10,8 @@ use std::pin::Pin; use serde::{Deserialize, Serialize}; +use crate::stdlib::shared::truncated; + pub const SKILLS_MODULE_NAME: &str = "submilli:skills"; /// One skill, as a listing shows it. @@ -40,9 +42,15 @@ pub enum SkillError { NotFound { name: String }, /// The skill has no file at this path. FileNotFound { name: String, path: String }, + /// The name is not one skill name. The engine refuses these before asking + /// the provider. + InvalidName { name: String }, /// The path is not a relative path inside the skill. The engine refuses /// these before asking the provider; a provider may refuse more. InvalidPath { path: String }, + /// The provider answered `load(name)` with a skill of another name. The + /// engine refuses it: the policy decided on `name`. + WrongSkill { name: String }, /// Reading failed for another reason. `message` is a fixed classification /// chosen by the provider. Failed { message: String }, @@ -57,14 +65,31 @@ impl std::fmt::Display for SkillError { ), Self::NotFound { name } => write!( f, - "no skill named `{name}`; call `list()` for the skills you may load" + "no skill named `{}`; call `list()` for the skills you may load", + truncated(name) + ), + Self::FileNotFound { name, path } => write!( + f, + "skill `{}` has no file `{}`", + truncated(name), + truncated(path) + ), + Self::InvalidName { name } => write!( + f, + "`{}` is not a skill name: use a name as `list()` returns it — one segment of \ + at most 4096 bytes, not empty, `.` or `..`, and without `/`, `\\` or NUL", + truncated(name) ), - Self::FileNotFound { name, path } => { - write!(f, "skill `{name}` has no file `{path}`") - } Self::InvalidPath { path } => write!( f, - "`{path}` is not a path inside a skill: use a relative path without `.` or `..` segments" + "`{}` is not a path inside a skill: use a relative path of at most 4096 bytes \ + with `/` separators, no empty, `.` or `..` segment, and no `\\`, `:` or NUL", + truncated(path) + ), + Self::WrongSkill { name } => write!( + f, + "the harness answered `{}` with a different skill", + truncated(name) ), Self::Failed { message } => write!(f, "{message}"), } @@ -75,20 +100,31 @@ impl std::error::Error for SkillError {} /// The harness side of `submilli:skills`. pub trait SkillProvider: Send + Sync { - /// Every skill the harness offers. The engine removes the ones the policy - /// denies to the caller before the program sees the list. + /// Every skill the harness offers, each under a name [`Self::load`] accepts. + /// The engine removes the ones the policy denies to the caller, and any whose + /// name it would refuse, before the program sees the list. fn list<'a>( &'a self, ) -> Pin, SkillError>> + Send + 'a>>; - /// The skill named `name`. + /// The skill named `name`, whose returned `name` must be exactly `name`. + /// + /// `name` comes from the program and the policy decided on it as written, so + /// match it byte for byte: no case folding, Unicode normalization or path + /// canonicalization, or a policy that denies `secrets` would let `Secrets` + /// through. The engine passes only one segment of at most 4096 bytes that is + /// not empty, `.` or `..` and has no `/`, `\` or NUL; it may contain `:`, so + /// never use it as a path. fn load<'a>( &'a self, name: &'a str, ) -> Pin> + Send + 'a>>; - /// The text of the file at `path` inside skill `name`. `path` is relative, - /// uses `/` separators and has no empty, `.` or `..` segment. + /// The text of the file at `path` inside skill `name`. `name` is checked and + /// must be matched as for [`Self::load`]. `path` is relative, uses `/` + /// separators, has no empty, `.` or `..` segment and no `\`, `:` or NUL, and + /// is at most 4096 bytes. The engine does not decode it: a provider that + /// percent-decodes must check the decoded path again. fn read_file<'a>( &'a self, name: &'a str, diff --git a/crates/interpreter/src/stdlib/agents/declaration.rs b/crates/interpreter/src/stdlib/agents/declaration.rs index db5cd4825..847a6c4b3 100644 --- a/crates/interpreter/src/stdlib/agents/declaration.rs +++ b/crates/interpreter/src/stdlib/agents/declaration.rs @@ -46,8 +46,8 @@ pub fn package_declaration() -> PackageDeclaration { * Without a type argument the answer is the agent's text. With one — \ `run(agent, input)` — a JSON Schema for `T` is emitted at compile time \ and sent with the task, and the answer is then checked structurally against \ - `T`. An answer that is not JSON, or does not match, throws a catchable \ - `TypeError`; nothing is coerced.\n *\n * `T` must be a type the schema can \ + `T`. An answer that is not JSON throws a catchable `SyntaxError`, and one \ + that does not match throws a catchable `TypeError`; nothing is coerced.\n *\n * `T` must be a type the schema can \ carry: no functions, no `bigint`, no `Uint8Array`, no `unknown`, and no \ recursive type.\n *\n * The harness runs the agent and decides how long it may \ take and what it may spend. A run that fails, is cancelled, or names an agent \ diff --git a/crates/interpreter/src/stdlib/agents/mod.rs b/crates/interpreter/src/stdlib/agents/mod.rs index f42aa857d..3baf302f2 100644 --- a/crates/interpreter/src/stdlib/agents/mod.rs +++ b/crates/interpreter/src/stdlib/agents/mod.rs @@ -34,8 +34,8 @@ use crate::stdlib::abi::{ self, backing_struct, install_field_getters, nullable_object_field, string_field, }; use crate::stdlib::shared::{ - check_security_call, filters_candidate, mark_filtered, preflight_listing, running_package, - sanitize_description, + check_security_call, permitted_candidates, preflight_listing, running_package, + sanitize_description, truncated, }; pub use declaration::package_declaration; @@ -121,8 +121,8 @@ pub fn install(linker: &mut Linker) -> wasmtime::Result<()> { ) } -/// One run: gate, record, dispatch, then build the result without refusing for -/// fuel, because the run has already happened. +/// One run: gate, charge, record what is sent, dispatch, then build the result +/// without refusing for fuel, because the run has already happened. async fn run( caller: &mut wasmtime::Caller<'_, StoreData>, agent: String, @@ -130,15 +130,15 @@ async fn run( schema: Option, ) -> wasmtime::Result { let ticket = gate(caller, &agent)?; + let provider = provider(caller).map_err(|error| fail(caller, ticket, "run", &error))?; + let principal = running_package(caller).map_err(|error| error.into_denial(CAPABILITY))?; let sent = (input.len() + schema.as_deref().map_or(0, str::len)) as u64; + fuel::charge(&mut *caller, fuel::IO, sent)?; record_payload(&*caller, ticket, Side::Request, || { Payload::meta(serde_json::json!({ "op": "run", "agent": agent, "schema": schema })) .with_owned_body(input.clone().into_bytes()) .with_size(sent) }); - let provider = provider(caller, "run")?; - fuel::charge(&mut *caller, fuel::IO, sent)?; - let principal = running_package(caller).map_err(|error| error.into_denial(CAPABILITY))?; let typed = schema.is_some(); let request = AgentRequest { agent: agent.clone(), @@ -155,7 +155,10 @@ async fn run( crate::runtime::json::parse_json_as_unknown( caller, &outcome.text, - &format!("agents.run(\"{agent}\"): the agent's result is not JSON"), + &format!( + "agents.run(\"{}\"): the agent's result is not JSON", + truncated(&agent) + ), ) } else { let text = write_submilli_string_struct(caller, &outcome.text)?; @@ -163,15 +166,23 @@ async fn run( } }) } - Err(error) => { - record_payload(&*caller, ticket, Side::Response, || { - Payload::meta(serde_json::json!({ "call_error": call_error_record(&error) })) - }); - Err(throw("run", &error)) - } + Err(error) => Err(fail(caller, ticket, "run", &error)), } } +/// Record `error` as the call's response and turn it into the guest's error. +fn fail( + caller: &wasmtime::Caller<'_, StoreData>, + ticket: Option, + op: &str, + error: &AgentCallError, +) -> wasmtime::Error { + record_payload(caller, ticket, Side::Response, || { + Payload::meta(serde_json::json!({ "call_error": call_error_record(error) })) + }); + throw(op, error) +} + fn record_outcome( caller: &wasmtime::Caller<'_, StoreData>, ticket: Option, @@ -209,20 +220,18 @@ fn gate( } /// `list()`: every agent the harness offers that the caller may run. A denied -/// candidate is left out, never reported. +/// candidate is left out, never reported. Whether a provider is wired is not +/// hidden here: a listing has no candidate to gate before asking it. async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result { preflight_listing(caller, CAPABILITY, &serde_json::json!({ "agent": "" }))?; - let provider = provider(caller, "list")?; + let provider = provider(caller).map_err(|error| throw("list", &error))?; let candidates = provider.agents().await.map_err(|e| throw("list", &e))?; - let mut visible = Vec::new(); - for candidate in candidates { - let keeps = filters_candidate(gate(caller, &candidate.name).map(|_| ()))?; - if keeps { - visible.push(candidate); - } else { - mark_filtered(&*caller); - } - } + let visible = permitted_candidates( + caller, + candidates, + |agent| agent.name.as_str(), + |caller, name| gate(caller, name).map(|_| ()), + )?; let mut built = Vec::with_capacity(visible.len()); for agent in visible { built.push(build_agent_info(caller, agent)?); @@ -230,17 +239,17 @@ async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result< abi::new_array(caller, &built) } -/// Clone the provider out of the store before any `await`. Runs after the -/// capability check, so a denied caller cannot learn whether a harness is wired. +/// Clone the provider out of the store before any `await`. `run` looks it up +/// after the capability check, so a denied caller cannot learn whether a harness +/// is wired. fn provider( caller: &wasmtime::Caller<'_, StoreData>, - op: &str, -) -> wasmtime::Result> { +) -> Result, AgentCallError> { caller .data() .agent_provider .clone() - .ok_or_else(|| throw(op, &AgentCallError::NotConfigured)) + .ok_or(AgentCallError::NotConfigured) } fn throw(op: &str, error: &AgentCallError) -> wasmtime::Error { diff --git a/crates/interpreter/src/stdlib/capabilities.rs b/crates/interpreter/src/stdlib/capabilities.rs index 0829eb00a..388baab9b 100644 --- a/crates/interpreter/src/stdlib/capabilities.rs +++ b/crates/interpreter/src/stdlib/capabilities.rs @@ -601,11 +601,11 @@ pub(crate) fn all_groups() -> impl Iterator { /// Look up a core capability by its exact name (templates included, by their /// literal `mcp.` spelling). pub fn find(name: &str) -> Option<&'static Capability> { - find_in(Stdlib::core(), name) + find_for(Stdlib::core(), name) } /// [`find`] among the capabilities of `stdlib`. -pub fn find_in(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { +pub fn find_for(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { catalog_for(stdlib) .into_iter() .flat_map(|group| group.capabilities) @@ -630,12 +630,12 @@ pub fn uncataloged_http_method(name: &str) -> Option<&str> { /// The entry describing `name`: its catalog entry, or [`HTTP_OTHER_METHOD`] /// for a name that fills it. pub fn find_gating(name: &str) -> Option<&'static Capability> { - find_gating_in(Stdlib::core(), name) + find_gating_for(Stdlib::core(), name) } /// [`find_gating`] among the capabilities of `stdlib`. -pub fn find_gating_in(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { - find_in(stdlib, name).or_else(|| uncataloged_http_method(name).map(|_| &HTTP_OTHER_METHOD)) +pub fn find_gating_for(stdlib: Stdlib, name: &str) -> Option<&'static Capability> { + find_for(stdlib, name).or_else(|| uncataloged_http_method(name).map(|_| &HTTP_OTHER_METHOD)) } /// An RFC 9110 method token, the set `http.request` accepts, in lowercase. diff --git a/crates/interpreter/src/stdlib/mod.rs b/crates/interpreter/src/stdlib/mod.rs index 0bb99dcd3..6c575642f 100644 --- a/crates/interpreter/src/stdlib/mod.rs +++ b/crates/interpreter/src/stdlib/mod.rs @@ -105,19 +105,33 @@ pub(crate) struct SchemaCheckedCall { pub checks: &'static str, /// Who the schema is sent to. pub answerer: &'static str, - /// The arguments a program writes, in prose. - pub written: &'static str, - pub written_count: usize, - /// The ordinal of the schema argument, in prose. - pub extra_argument: &'static str, - /// How to do without a type argument, in three phrasings. - pub untyped_read: &'static str, - pub untyped_unknown: &'static str, - pub untyped_parse: &'static str, + /// The parameters a program writes, in prose; the schema parameter follows. + pub written_params: &'static str, + pub written_param_count: usize, + /// Ends the "cannot be verified" diagnostics: what to do instead of a type + /// argument the runtime cannot test. + pub untyped_hint: &'static str, + /// Ends the `` diagnostic. + pub untyped_hint_for_unknown: &'static str, + /// Ends the "has no JSON Schema" diagnostic. + pub untyped_hint_for_no_schema: &'static str, /// What `T` binds to when the program wrote no type argument. pub untyped_result: Type, } +impl SchemaCheckedCall { + /// The schema parameter's position, as an ordinal word. + pub fn schema_argument_ordinal(&self) -> &'static str { + match self.written_param_count { + 0 => "first", + 1 => "second", + 2 => "third", + 3 => "fourth", + _ => "last", + } + } +} + /// The schema-checked call `mangled` names, if it is one. pub(crate) fn schema_checked_call(mangled: &MangledName) -> Option { if llm::declaration::is_checked_call(mangled) { @@ -126,12 +140,11 @@ pub(crate) fn schema_checked_call(mangled: &MangledName) -> Option(model, prompt)", checks: "the model's response", answerer: "the model", - written: "the model and the prompt", - written_count: 2, - extra_argument: "third", - untyped_read: "read the `Completion` envelope yourself", - untyped_unknown: "read the `Completion` envelope's `ok` and `text` yourself", - untyped_parse: "parse the `Completion` text yourself", + written_params: "the model and the prompt", + written_param_count: 2, + untyped_hint: "read the `Completion` envelope yourself", + untyped_hint_for_unknown: "read the `Completion` envelope's `ok` and `text` yourself", + untyped_hint_for_no_schema: "parse the `Completion` text yourself", untyped_result: llm::declaration::untyped_result_type(mangled), }); } @@ -141,12 +154,11 @@ pub(crate) fn schema_checked_call(mangled: &MangledName) -> Option(agent, input)", checks: "the agent's result", answerer: "the agent", - written: "the agent and the input", - written_count: 2, - extra_argument: "third", - untyped_read: "read the returned text yourself", - untyped_unknown: "read the returned text yourself", - untyped_parse: "parse the returned text yourself", + written_params: "the agent and the input", + written_param_count: 2, + untyped_hint: "read the returned text yourself", + untyped_hint_for_unknown: "read the returned text yourself", + untyped_hint_for_no_schema: "parse the returned text yourself", untyped_result: Type::String, }); } @@ -158,6 +170,8 @@ pub(crate) fn schema_checked_call(mangled: &MangledName) -> Option Stdlib { .with(OptionalPackage::Skills) } -/// Answers every run with `answer` and records what it was asked. +/// Answers every run with `answer`, lists `listing`, and records what it was +/// asked to run. struct FakeAgents { answer: Result, + listing: Result, AgentCallError>, requests: Mutex>, } @@ -33,6 +35,7 @@ impl FakeAgents { fn answering(answer: &str) -> Arc { Arc::new(Self { answer: Ok(answer.to_string()), + listing: Ok(two_agents()), requests: Mutex::new(Vec::new()), }) } @@ -40,6 +43,15 @@ impl FakeAgents { fn failing(error: AgentCallError) -> Arc { Arc::new(Self { answer: Err(error), + listing: Ok(two_agents()), + requests: Mutex::new(Vec::new()), + }) + } + + fn listing(listing: Result, AgentCallError>) -> Arc { + Arc::new(Self { + answer: Ok(String::new()), + listing, requests: Mutex::new(Vec::new()), }) } @@ -65,29 +77,35 @@ impl AgentProvider for FakeAgents { } fn agents<'a>(&'a self) -> Boxed<'a, Result, AgentCallError>> { - Box::pin(async { - Ok(vec![ - AgentInfo { - name: "researcher".to_string(), - description: Some("Finds\nsources".to_string()), - }, - AgentInfo { - name: "deployer".to_string(), - description: None, - }, - ]) - }) + let listing = self.listing.clone(); + Box::pin(async move { listing }) } } -/// Two skills; `review` bundles one file. +fn two_agents() -> Vec { + vec![ + AgentInfo { + name: "researcher".to_string(), + description: Some("Finds\nsources".to_string()), + }, + AgentInfo { + name: "deployer".to_string(), + description: None, + }, + ] +} + +/// Two skills; `review` bundles one file. Records every name it is asked to +/// load and every file it is asked to read. struct FakeSkills { + loads: Mutex>, reads: Mutex>, } impl FakeSkills { fn new() -> Arc { Arc::new(Self { + loads: Mutex::new(Vec::new()), reads: Mutex::new(Vec::new()), }) } @@ -105,11 +123,17 @@ impl SkillProvider for FakeSkills { name: "internal".to_string(), description: None, }, + // Not one name: `load` would refuse it, so `list()` drops it. + SkillInfo { + name: "team/review".to_string(), + description: None, + }, ]) }) } fn load<'a>(&'a self, name: &'a str) -> Boxed<'a, Result> { + self.loads.lock().expect("loads").push(name.to_string()); Box::pin(async move { match name { "review" => Ok(Skill { @@ -306,11 +330,11 @@ fn only_an_enabling_set_discovers_and_catalogs_the_packages() { } for capability in ["agent.run", "skill.load"] { assert!(capabilities::find(capability).is_none()); - assert!(capabilities::find_in(harness_stdlib(), capability).is_some()); + assert!(capabilities::find_for(harness_stdlib(), capability).is_some()); } let agents_only = Stdlib::core().with(OptionalPackage::Agents); - assert!(capabilities::find_in(agents_only, "agent.run").is_some()); - assert!(capabilities::find_in(agents_only, "skill.load").is_none()); + assert!(capabilities::find_for(agents_only, "agent.run").is_some()); + assert!(capabilities::find_for(agents_only, "skill.load").is_none()); } #[test] @@ -509,3 +533,247 @@ async fn read_file_is_gated_by_the_skill_and_refuses_paths_outside_it() { "neither call may reach the harness" ); } + +#[test] +fn an_unknown_type_argument_is_refused_in_agents_words() { + let errors = compile_errors( + "import agents from \"submilli:agents\";\n\ + function main(): void { agents.run(\"researcher\", \"go\"); }\n", + harness_stdlib(), + ); + assert!( + errors.iter().any( + |e| e.contains("`agents.run` would not verify anything") + && e.contains("agents.run(agent, input)") + ), + "{errors:?}" + ); +} + +#[test] +fn a_parsed_script_typechecks_against_an_enabling_set() { + let source = "import { list } from \"submilli:skills\";\nfunction main(): void { list(); }\n"; + let parsed = crate::parse_script(source, crate::FileId(0)); + crate::compile::typecheck_parsed_checked( + source, + &parsed, + &harness_stdlib().package_declarations(), + ) + .expect("skills is available"); + assert!( + crate::compile::typecheck_parsed_checked( + source, + &parsed, + &Stdlib::core().package_declarations() + ) + .is_err() + ); +} + +#[test] +fn a_package_compiles_against_an_enabling_set() { + let source = "import { list } from \"submilli:agents\";\n\ + export function names(): string[] { return list().map((a) => a.name); }\n"; + let modules = [crate::PackageSourceModule { + path: crate::ModulePath::from("lib"), + source, + }]; + crate::compile::compile_package_with_transitive_checked_for( + harness_stdlib(), + "@acme/fanout", + crate::ModulePath::from("lib"), + &modules, + &[], + &[], + ) + .expect("agents is importable"); + assert!( + crate::compile::compile_package_with_transitive_checked( + "@acme/fanout", + crate::ModulePath::from("lib"), + &modules, + &[], + &[], + ) + .is_err() + ); +} + +#[tokio::test] +async fn a_typed_run_with_a_prose_answer_throws_a_syntax_error() { + let out = Harness::default() + .agents(FakeAgents::answering("Sure, here is the report")) + .run( + r#"import agents from "submilli:agents"; + interface Review { score: number } + function main(): string { + try { + agents.run("researcher", "review it"); + return "accepted"; + } catch (e: SyntaxError) { + return "not json"; + } + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "not json"); +} + +#[tokio::test] +async fn an_empty_or_failed_listing_is_what_the_program_sees() { + let empty = Harness::default() + .agents(FakeAgents::listing(Ok(Vec::new()))) + .run( + r#"import agents from "submilli:agents"; + function main(): string { return String(agents.list().length); }"#, + ) + .await + .expect("program completes"); + assert_eq!(empty, "0"); + + let failed = Harness::default() + .agents(FakeAgents::listing(Err(AgentCallError::Failed { + agent: String::new(), + message: "catalog unavailable".to_string(), + }))) + .run( + r#"import agents from "submilli:agents"; + function main(): string { + try { agents.list(); return "listed"; } catch (e) { return e.message; } + }"#, + ) + .await + .expect("program completes"); + assert!(failed.contains("catalog unavailable"), "{failed}"); +} + +#[tokio::test] +async fn a_skill_name_that_is_not_one_segment_never_reaches_the_harness() { + let skills = FakeSkills::new(); + let out = Harness::default() + .skills(skills.clone()) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + let out = ""; + for (const name of ["../other", "a/b", "", ".."]) { + try { skills.load(name); out += "loaded "; } + catch (e: RangeError) { out += "range "; } + } + try { skills.readFile("../../etc", "passwd"); out += "read"; } + catch (e: RangeError) { out += "range"; } + return out; + }"#, + ) + .await + .expect("program completes"); + assert_eq!(out, "range range range range range"); + assert!(skills.loads.lock().expect("loads").is_empty()); + assert!(skills.reads.lock().expect("reads").is_empty()); +} + +#[tokio::test] +async fn an_unknown_skill_and_a_missing_provider_are_catchable() { + let source = r#"import skills from "submilli:skills"; + function main(): string { + try { skills.load("nope"); return "loaded"; } catch (e) { return e.message; } + }"#; + let unknown = Harness::default() + .skills(FakeSkills::new()) + .run(source) + .await + .expect("program completes"); + assert_eq!( + unknown, + "skills.load: no skill named `nope`; call `list()` for the skills you may load" + ); + + let unconfigured = Harness::default() + .run(source) + .await + .expect("program completes"); + assert!( + unconfigured.contains("no skill provider is configured"), + "{unconfigured}" + ); +} + +#[tokio::test] +async fn a_namespaced_skill_name_reaches_the_harness() { + let skills = FakeSkills::new(); + let out = Harness::default() + .skills(skills.clone()) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + try { skills.load("plugin:review"); return "loaded"; } catch (e) { return e.message; } + }"#, + ) + .await + .expect("program completes"); + assert!(out.contains("no skill named `plugin:review`"), "{out}"); + assert_eq!(*skills.loads.lock().expect("loads"), ["plugin:review"]); +} + +/// Answers every load with the `review` skill, whatever was asked for. +struct CaseFoldingSkills; + +impl SkillProvider for CaseFoldingSkills { + fn list<'a>(&'a self) -> Boxed<'a, Result, SkillError>> { + Box::pin(async { Ok(Vec::new()) }) + } + + fn load<'a>(&'a self, _name: &'a str) -> Boxed<'a, Result> { + Box::pin(async { + Ok(Skill { + name: "review".to_string(), + description: None, + content: "Read the diff twice.".to_string(), + }) + }) + } + + fn read_file<'a>( + &'a self, + _name: &'a str, + _path: &'a str, + ) -> Boxed<'a, Result> { + Box::pin(async { Ok(String::new()) }) + } +} + +/// The policy decided on the name the program wrote, so a skill answered under +/// another name is refused rather than handed over. +#[tokio::test] +async fn a_skill_answered_under_another_name_is_refused() { + let out = Harness::default() + .skills(Arc::new(CaseFoldingSkills)) + .policy(DenyOne::new("name", "review")) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + try { return skills.load("Review").content; } catch (e) { return e.message; } + }"#, + ) + .await + .expect("program completes"); + assert!(out.contains("with a different skill"), "{out}"); +} + +#[tokio::test] +async fn an_oversized_name_is_refused_with_a_short_message() { + let out = Harness::default() + .skills(FakeSkills::new()) + .run( + r#"import skills from "submilli:skills"; + function main(): string { + try { skills.load("x".repeat(5000)); return "loaded"; } + catch (e: RangeError) { return e.message; } + }"#, + ) + .await + .expect("program completes"); + assert!(out.contains("at most 4096 bytes"), "{out}"); + assert!(out.len() < 600, "{}", out.len()); +} diff --git a/crates/interpreter/src/stdlib/shared.rs b/crates/interpreter/src/stdlib/shared.rs index 629a45203..03bc2652e 100644 --- a/crates/interpreter/src/stdlib/shared.rs +++ b/crates/interpreter/src/stdlib/shared.rs @@ -556,6 +556,38 @@ pub(crate) fn filters_candidate(checked: wasmtime::Result<()>) -> wasmtime::Resu } } +/// The candidates of a listing the caller may use. `gate` runs the capability +/// check one candidate's use would; a policy denial leaves the candidate out and +/// marks the recorded decision filtered, and any other refusal propagates, the +/// [`filters_candidate`] rule. +pub(crate) fn permitted_candidates( + caller: &mut wasmtime::Caller<'_, StoreData>, + candidates: Vec, + name_of: impl Fn(&T) -> &str, + mut gate: impl FnMut(&mut wasmtime::Caller<'_, StoreData>, &str) -> wasmtime::Result<()>, +) -> wasmtime::Result> { + let mut permitted = Vec::with_capacity(candidates.len()); + for candidate in candidates { + if filters_candidate(gate(caller, name_of(&candidate)))? { + permitted.push(candidate); + } else { + mark_filtered(&*caller); + } + } + Ok(permitted) +} + +/// At most the first 200 bytes of a program-supplied value, for an error that +/// echoes it: a refused value may be refused for its size. +pub(crate) fn truncated(value: &str) -> std::borrow::Cow<'_, str> { + const MAX_ECHO_BYTES: usize = 200; + if value.len() <= MAX_ECHO_BYTES { + return std::borrow::Cow::Borrowed(value); + } + let end = value.floor_char_boundary(MAX_ECHO_BYTES); + std::borrow::Cow::Owned(format!("{}…", value.get(..end).unwrap_or_default())) +} + /// Reduce an operator-authored `description` to inert single-line data. /// /// This is sanitization, not merely a bound. The text flows verbatim into a diff --git a/crates/interpreter/src/stdlib/skills/declaration.rs b/crates/interpreter/src/stdlib/skills/declaration.rs index 43b51b216..9f925fdec 100644 --- a/crates/interpreter/src/stdlib/skills/declaration.rs +++ b/crates/interpreter/src/stdlib/skills/declaration.rs @@ -39,9 +39,11 @@ pub fn package_declaration() -> PackageDeclaration { vec![Param::new("name", Type::String)], interface_type("Skill"), "/**\n * Load the skill `name`: its description and its instructions.\n *\n * \ - Throws a catchable error when the harness has no skill of that name, or when \ - this runtime has no skill provider.\n * @param name Skill name. Call `list()` \ - for the skills you may load.\n * @capability skill.load { name: $name }\n */", + A name that is not one skill name — empty, `.` or `..`, containing `/`, \ + `\\` or NUL, or over 4096 bytes — throws a `RangeError` without asking the \ + harness. Throws a catchable error when the harness has no skill of that name, \ + or when this runtime has no skill provider.\n * @param name Skill name, as \ + `list()` returns it.\n * @capability skill.load { name: $name }\n */", ); insert_fn( &mut defs, @@ -53,9 +55,12 @@ pub fn package_declaration() -> PackageDeclaration { Type::String, "/**\n * Read a file bundled with the skill `name`, as text.\n *\n * `path` is \ relative to the skill, with `/` separators, as the skill's instructions name \ - it — `\"templates/report.md\"`. An absolute path, or one with an empty, `.` \ - or `..` segment, throws a `RangeError` without asking the harness; a file the \ - skill does not have throws a catchable error.\n * @param name Skill name.\n \ + it — `\"templates/report.md\"`. An absolute path, one with an empty, `.` \ + or `..` segment, one containing `\\`, `:` or NUL, or one over 4096 bytes, \ + throws a `RangeError` \ + without asking the harness, as does a name that is not one skill name; a file \ + the skill does not have throws a catchable error.\n * @param name Skill name, \ + as `list()` returns it.\n \ * @param path The file's path inside the skill.\n * @capability skill.load { \ name: $name }\n */", ); diff --git a/crates/interpreter/src/stdlib/skills/mod.rs b/crates/interpreter/src/stdlib/skills/mod.rs index 1bcdfcde3..c205f4612 100644 --- a/crates/interpreter/src/stdlib/skills/mod.rs +++ b/crates/interpreter/src/stdlib/skills/mod.rs @@ -30,7 +30,7 @@ use crate::stdlib::abi::{ self, backing_struct, install_field_getters, nullable_object_field, string_field, }; use crate::stdlib::shared::{ - check_security_call, filters_candidate, mark_filtered, preflight_listing, sanitize_description, + check_security_call, permitted_candidates, preflight_listing, sanitize_description, truncated, }; pub use declaration::package_declaration; @@ -114,17 +114,21 @@ pub fn install(linker: &mut Linker) -> wasmtime::Result<()> { }, )?; - for iface in ["SkillInfo", "Skill"] { - let mut rows = vec![ - ("name", S_NAME, string.clone()), - ("description", S_DESCRIPTION, nullable_object.clone()), - ]; - if iface == "Skill" { - rows.push(("content", S_CONTENT, string.clone())); - } - install_field_getters(linker, MODULE_NAME, iface, &engine, &object, &rows)?; - } - Ok(()) + let info_rows = [ + ("name", S_NAME, string.clone()), + ("description", S_DESCRIPTION, nullable_object), + ]; + install_field_getters( + linker, + MODULE_NAME, + "SkillInfo", + &engine, + &object, + &info_rows, + )?; + let mut skill_rows = info_rows.to_vec(); + skill_rows.push(("content", S_CONTENT, string)); + install_field_getters(linker, MODULE_NAME, "Skill", &engine, &object, &skill_rows) } /// The capability check, run before anything reaches the harness. @@ -136,20 +140,23 @@ fn gate( } /// `list()`: every skill the harness offers that the caller may load. A denied -/// candidate is left out, never reported. +/// candidate is left out, never reported. Whether a provider is wired is not +/// hidden here: a listing has no candidate to gate before asking it. async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result { preflight_listing(caller, CAPABILITY, &serde_json::json!({ "name": "" }))?; - let provider = provider(caller, "list")?; + let provider = provider(caller).map_err(|error| throw("list", &error))?; let candidates = provider.list().await.map_err(|e| throw("list", &e))?; - let mut visible = Vec::new(); - for candidate in candidates { - let keeps = filters_candidate(gate(caller, &candidate.name).map(|_| ()))?; - if keeps { - visible.push(candidate); - } else { - mark_filtered(&*caller); - } - } + // A name `load` would refuse is no use to the program, so it is not offered. + let loadable = candidates + .into_iter() + .filter(|skill| is_skill_name(&skill.name)) + .collect(); + let visible = permitted_candidates( + caller, + loadable, + |skill| skill.name.as_str(), + |caller, name| gate(caller, name).map(|_| ()), + )?; let mut built = Vec::with_capacity(visible.len()); for skill in visible { built.push(build_skill_info(caller, skill)?); @@ -157,13 +164,36 @@ async fn list(caller: &mut wasmtime::Caller<'_, StoreData>) -> wasmtime::Result< abi::new_array(caller, &built) } +/// `load(name)`: gate, refuse what cannot be sent, record the request, then ask +/// the provider. A refusal before the provider is asked is recorded as the +/// call's error, with no request. async fn load(caller: &mut wasmtime::Caller<'_, StoreData>, name: String) -> wasmtime::Result { let ticket = gate(caller, &name)?; + if !is_skill_name(&name) { + return Err(fail( + caller, + ticket, + "load", + &SkillError::InvalidName { name }, + )); + } + let provider = provider(caller).map_err(|error| fail(caller, ticket, "load", &error))?; record_payload(&*caller, ticket, Side::Request, || { Payload::meta(serde_json::json!({ "op": "load", "name": name })) }); - let provider = provider(caller, "load")?; match provider.load(&name).await { + // The policy decided on `name`; a provider that answered with another + // skill would hand the program one the policy never saw. + Ok(skill) if skill.name != name => { + // The read happened, so it is paid for; its content is not kept. + fuel::settle(&mut *caller, fuel::IO, skill.content.len() as u64)?; + Err(fail( + caller, + ticket, + "load", + &SkillError::WrongSkill { name }, + )) + } Ok(skill) => { record_text(caller, ticket, &skill.content); fuel::settle(&mut *caller, fuel::IO, skill.content.len() as u64)?; @@ -173,15 +203,22 @@ async fn load(caller: &mut wasmtime::Caller<'_, StoreData>, name: String) -> was } } +/// `readFile(name, path)`: in the order `load` follows, with the path checked +/// beside the name. async fn read_file( caller: &mut wasmtime::Caller<'_, StoreData>, name: String, path: String, ) -> wasmtime::Result { let ticket = gate(caller, &name)?; - record_payload(&*caller, ticket, Side::Request, || { - Payload::meta(serde_json::json!({ "op": "readFile", "name": name, "path": path })) - }); + if !is_skill_name(&name) { + return Err(fail( + caller, + ticket, + "readFile", + &SkillError::InvalidName { name }, + )); + } if !is_skill_path(&path) { return Err(fail( caller, @@ -190,7 +227,10 @@ async fn read_file( &SkillError::InvalidPath { path }, )); } - let provider = provider(caller, "readFile")?; + let provider = provider(caller).map_err(|error| fail(caller, ticket, "readFile", &error))?; + record_payload(&*caller, ticket, Side::Request, || { + Payload::meta(serde_json::json!({ "op": "readFile", "name": name, "path": path })) + }); match provider.read_file(&name, &path).await { Ok(text) => { record_text(caller, ticket, &text); @@ -204,10 +244,25 @@ async fn read_file( } } +/// The longest skill name, and the longest path, the engine passes to a +/// provider. +const MAX_SKILL_ARG_BYTES: usize = 4096; + +/// A skill name: one segment that is not `.` or `..`, with no `/`, `\\` or NUL. +/// `:` is allowed, for namespaced names such as `plugin:skill`; a provider must +/// not read a name as a path. +fn is_skill_name(name: &str) -> bool { + name.len() <= MAX_SKILL_ARG_BYTES + && !name.contains(['/', '\\', '\0']) + && !matches!(name, "" | "." | "..") +} + /// A path inside a skill: relative, `/`-separated, with no empty, `.` or `..` -/// segment, and no backslash or NUL a provider could read as structure. +/// segment, and none of the characters a provider could read as structure — a +/// backslash or `:` (Windows separators, drives and streams) or NUL. fn is_skill_path(path: &str) -> bool { - !path.contains(['\\', '\0']) + path.len() <= MAX_SKILL_ARG_BYTES + && !path.contains(['\\', ':', '\0']) && path .split('/') .all(|segment| !matches!(segment, "" | "." | "..")) @@ -229,44 +284,54 @@ fn fail( error: &SkillError, ) -> wasmtime::Error { record_payload(caller, ticket, Side::Response, || { - Payload::meta(serde_json::json!({ "call_error": error_record(error) })) + Payload::meta(serde_json::json!({ "call_error": call_error_record(error) })) }); throw(op, error) } -/// Clone the provider out of the store before any `await`. Runs after the -/// capability check, so a denied caller cannot learn whether a harness is wired. +/// Clone the provider out of the store before any `await`. `load` and +/// `readFile` look it up after the capability check, so a denied caller cannot +/// learn whether a harness is wired. fn provider( caller: &wasmtime::Caller<'_, StoreData>, - op: &str, -) -> wasmtime::Result> { +) -> Result, SkillError> { caller .data() .skill_provider .clone() - .ok_or_else(|| throw(op, &SkillError::NotConfigured)) + .ok_or(SkillError::NotConfigured) } -/// A path outside the skill is an argument the program got wrong; every other -/// failure keeps the base error type. +/// A name or path outside the skills is an argument the program got wrong; every +/// other failure keeps the base error type. fn throw(op: &str, error: &SkillError) -> wasmtime::Error { let message = format!("skills.{op}: {error}"); - if matches!(error, SkillError::InvalidPath { .. }) { + if matches!( + error, + SkillError::InvalidName { .. } | SkillError::InvalidPath { .. } + ) { range_error(message) } else { wasmtime::Error::msg(message) } } -fn error_record(error: &SkillError) -> serde_json::Value { +/// A failure as the call log keeps it: a stable kind and what it was about. +fn call_error_record(error: &SkillError) -> serde_json::Value { match error { SkillError::NotConfigured => serde_json::json!({ "kind": "not-configured" }), SkillError::NotFound { name } => serde_json::json!({ "kind": "not-found", "name": name }), SkillError::FileNotFound { name, path } => { serde_json::json!({ "kind": "file-not-found", "name": name, "path": path }) } + SkillError::InvalidName { name } => { + serde_json::json!({ "kind": "invalid-name", "name": truncated(name) }) + } + SkillError::WrongSkill { name } => { + serde_json::json!({ "kind": "wrong-skill", "name": name }) + } SkillError::InvalidPath { path } => { - serde_json::json!({ "kind": "invalid-path", "path": path }) + serde_json::json!({ "kind": "invalid-path", "path": truncated(path) }) } SkillError::Failed { message } => { serde_json::json!({ "kind": "failed", "message": message }) @@ -301,7 +366,7 @@ fn build_skill_info( skill: SkillInfo, ) -> wasmtime::Result { let name = write_submilli_string_struct(caller, &skill.name)?; - let description = description(caller, skill.description.as_deref(), true)?; + let description = listing_description(caller, skill.description.as_deref())?; let ty = info_backing_struct(caller.engine())?; abi::new_backing( caller, @@ -315,7 +380,7 @@ fn build_skill( skill: Skill, ) -> wasmtime::Result { let name = write_submilli_string_struct(caller, &skill.name)?; - let description = description(caller, skill.description.as_deref(), false)?; + let description = optional_text(caller, skill.description.as_deref())?; let content = write_submilli_string_struct(caller, &skill.content)?; let ty = skill_backing_struct(caller.engine())?; abi::new_backing( @@ -330,21 +395,22 @@ fn build_skill( } /// A listing shows a description as one bounded line, because it steers which -/// skill a program picks; a loaded skill's description is part of what the -/// program asked to read. -fn description( +/// skill a program picks. +fn listing_description( + caller: &mut wasmtime::Caller<'_, StoreData>, + text: Option<&str>, +) -> wasmtime::Result { + optional_text(caller, text.and_then(sanitize_description).as_deref()) +} + +/// `text` as a string, or `undefined` when absent. +fn optional_text( caller: &mut wasmtime::Caller<'_, StoreData>, text: Option<&str>, - in_listing: bool, ) -> wasmtime::Result { - let text = if in_listing { - text.and_then(sanitize_description) - } else { - text.map(str::to_string) - }; match text { Some(text) => Ok(Val::AnyRef(Some( - write_submilli_string_struct(caller, &text)?.to_anyref(), + write_submilli_string_struct(caller, text)?.to_anyref(), ))), None => crate::runtime::prelude::undefined::value(caller), } @@ -352,13 +418,26 @@ fn description( #[cfg(test)] mod path_tests { - use super::is_skill_path; + use super::{MAX_SKILL_ARG_BYTES, is_skill_name, is_skill_path}; + use crate::stdlib::shared::truncated; #[test] fn only_relative_paths_inside_the_skill_are_accepted() { - for ok in ["SKILL.md", "templates/report.md", "a/b/c.txt", ".hidden"] { + let longest = "a".repeat(MAX_SKILL_ARG_BYTES); + for ok in [ + "SKILL.md", + "templates/report.md", + "a/b/c.txt", + ".hidden", + "notes/résumé ✓.md", + "%2e%2e/x", + longest.as_str(), + ] { assert!(is_skill_path(ok), "{ok}"); } + let too_long = "a".repeat(MAX_SKILL_ARG_BYTES + 1); + // 4095 ASCII bytes and a two-byte character: 4097 bytes, 4096 chars. + let straddling = format!("{}é", "a".repeat(MAX_SKILL_ARG_BYTES - 1)); for bad in [ "", "/etc/passwd", @@ -370,8 +449,51 @@ mod path_tests { "a/", "a\\b", "a\0b", + "a:b", + "C:/x", + "C:x", + "SKILL.md:stream", + too_long.as_str(), + straddling.as_str(), ] { assert!(!is_skill_path(bad), "{bad:?}"); } } + + #[test] + fn a_skill_name_is_one_segment_and_may_be_namespaced() { + let longest = "n".repeat(MAX_SKILL_ARG_BYTES); + for ok in [ + "code-review", + "code.review", + "plugin:skill", + "C:", + longest.as_str(), + ] { + assert!(is_skill_name(ok), "{ok}"); + } + let too_long = "n".repeat(MAX_SKILL_ARG_BYTES + 1); + for bad in [ + "", + ".", + "..", + "../other", + "a/b", + "a\\b", + "a\0b", + too_long.as_str(), + ] { + assert!(!is_skill_name(bad), "{bad:?}"); + } + } + + #[test] + fn an_echoed_value_is_cut_on_a_character_boundary() { + assert_eq!(truncated("short"), "short"); + let exactly = "a".repeat(200); + assert_eq!(truncated(&exactly), exactly.as_str()); + // Three-byte characters: byte 200 falls inside one, so the cut is at 198. + let cut = truncated(&"€".repeat(100)).into_owned(); + assert_eq!(cut, format!("{}…", "€".repeat(66))); + } } diff --git a/crates/interpreter/src/typechecker/infer/expr.rs b/crates/interpreter/src/typechecker/infer/expr.rs index c5cb5d50b..b3765da8e 100644 --- a/crates/interpreter/src/typechecker/infer/expr.rs +++ b/crates/interpreter/src/typechecker/infer/expr.rs @@ -3510,8 +3510,9 @@ impl Inferer<'_> { }) } - /// Rewrite `llm.call(model, prompt)` into a runtime-checked cast, and - /// emit the JSON Schema for `T` that rides along to the provider. + /// Rewrite a schema-checked call such as `llm.call(model, prompt)` into a + /// runtime-checked cast, and emit the JSON Schema for `T` that rides along + /// to the provider. /// /// Mirrors [`Self::checked_session_get`] — same soundness argument, same /// `checked_cast_around` — with one addition: the schema gate. A typed call @@ -3525,14 +3526,14 @@ impl Inferer<'_> { /// has to replace the trailing `schema` argument before the call node's /// argument list is frozen. `Ok(None)` is the untyped form, which sends no /// schema and gets no check; `Ok(Some(schema))` means both gates passed and - /// the caller must wrap the call in [`Self::checked_llm_cast`]; `Err(())` + /// the caller must wrap the call in [`Self::schema_checked_cast`]; `Err(())` /// means a diagnostic was reported (or deliberately suppressed) and the /// call is an error. /// /// `checked` describes the call, from [`crate::stdlib::schema_checked_call`]. /// `type_args_written` separates an explicit `call` from a bare /// `call(...)`, whose result is the untyped default and needs no check. - pub(super) fn llm_call_schema( + pub(super) fn schema_checked_call_schema( &mut self, checked: &crate::stdlib::SchemaCheckedCall, result_ty: &Type, @@ -3544,9 +3545,9 @@ impl Inferer<'_> { example, checks, answerer, - untyped_read, - untyped_unknown, - untyped_parse, + untyped_hint, + untyped_hint_for_unknown, + untyped_hint_for_no_schema, .. } = checked; // No type argument: the call keeps its pre-generic meaning and returns @@ -3569,7 +3570,7 @@ impl Inferer<'_> { ), vec![format!( "name the shape you expect — `{example}` — or drop the type argument \ - and {untyped_unknown}." + and {untyped_hint_for_unknown}." )], ); return Err(()); @@ -3595,7 +3596,7 @@ impl Inferer<'_> { that argument must be one the runtime can test, and the schema is \ emitted at compile time where `{result_ty}` is not yet known. Call it \ at a concrete type — `{example}` — inside the \ - generic function, or drop the type argument and {untyped_read}." + generic function, or drop the type argument and {untyped_hint}." )], ); return Err(()); @@ -3605,7 +3606,7 @@ impl Inferer<'_> { // narrower (KTD5) *and* its rejections name the offending field. A // recursive type fails both; the schema reason points at the field that // closes the cycle, which is the one the author has to change. - match self.llm_schema_for(result_ty) { + match self.json_schema_for(result_ty) { Ok(schema) => { // The cast gate still has to pass: it is what `checked_cast_around` // will re-run, and the two surfaces agree everywhere except the @@ -3622,7 +3623,7 @@ impl Inferer<'_> { an object, array, tuple, union, or primitive shape. Call it \ at a concrete type instead of `{result_ty}` — \ `{example}` — or drop the type \ - argument and {untyped_read}." + argument and {untyped_hint}." )], ); return Err(()); @@ -3644,7 +3645,7 @@ impl Inferer<'_> { `$ref`, so every field must be an object, array, tuple, union, \ enum, or primitive shape. Replace that field with one — a \ `string` for bytes or a big number, a named shape in place of \ - `unknown` — or drop the type argument and {untyped_parse}." + `unknown` — or drop the type argument and {untyped_hint_for_no_schema}." )], ); } @@ -3653,12 +3654,13 @@ impl Inferer<'_> { } } - /// Wrap a gated `llm.call` in its checked cast. Split from - /// [`Self::llm_call_schema`] because the gates must run before the call - /// node's arguments are frozen and this must run after. `checked_cast_around` - /// cannot fail here: `llm_call_schema` already ran the same cast gate on the - /// same type, and passing it is what produced the schema that got us here. - pub(super) fn checked_llm_cast( + /// Wrap a gated schema-checked call in its checked cast. Split from + /// [`Self::schema_checked_call_schema`] because the gates must run before the + /// call node's arguments are frozen and this must run after. + /// `checked_cast_around` cannot fail here: `schema_checked_call_schema` + /// already ran the same cast gate on the same type, and passing it is what + /// produced the schema that got us here. + pub(super) fn schema_checked_cast( &mut self, call: TypedExprKind, result_ty: &Type, @@ -3717,7 +3719,7 @@ impl Inferer<'_> { /// resolves alias back-edges through the type namespace — without that /// expander every `AliasRef` survives the walk and is rejected as /// unresolvable. - fn llm_schema_for( + fn json_schema_for( &mut self, target_ty: &Type, ) -> Result { diff --git a/crates/interpreter/src/typechecker/infer/generic.rs b/crates/interpreter/src/typechecker/infer/generic.rs index 2565dec49..a3a6b2887 100644 --- a/crates/interpreter/src/typechecker/infer/generic.rs +++ b/crates/interpreter/src/typechecker/infer/generic.rs @@ -2252,11 +2252,12 @@ impl Inferer<'_> { // ordinary generic call; the two sites below are the two halves of that // one decision, so it is read once here. let checked_get = crate::stdlib::session::declaration::is_checked_get(&mangled); - // `llm.call` / `llm.batch` lower the same way and for the same - // reason. They differ from `session.get` only in what a bare call means - // — the `Completion` envelope rather than an unchecked `unknown` — and - // in carrying a compile-time schema into the trailing argument. - let checked_llm = crate::stdlib::schema_checked_call(&mangled); + // Schema-checked calls (`llm.call`, `llm.batch`, `agents.run`) + // lower the same way and for the same reason. They differ from + // `session.get` only in what a bare call means — a typed default such as + // the `Completion` envelope rather than an unchecked `unknown` — and in + // carrying a compile-time schema into the trailing argument. + let schema_checked = crate::stdlib::schema_checked_call(&mangled); if let Some(targs) = &type_args { if targs.len() != generics.len() { @@ -2371,7 +2372,7 @@ impl Inferer<'_> { // is not an unchecked read, it is a different fully-typed result. `T` // appears only in the return type, so it is never inferable from an // argument and would otherwise always trip the unbound-parameter error. - if let Some(checked) = &checked_llm + if let Some(checked) = &schema_checked && !type_args_written { bind_remaining( @@ -2433,12 +2434,12 @@ impl Inferer<'_> { // unaffected in behavior — `substitute_schema_argument` overwrites the // slot — but a written argument there is equally meaningless, so both // forms are refused and no working program changes. - if let Some(checked) = &checked_llm - && args.len() > checked.written_count + if let Some(checked) = &schema_checked + && args.len() > checked.written_param_count { let name = &callee_ident.name; - let written = checked.written; - let extra = checked.extra_argument; + let written = checked.written_params; + let extra = checked.schema_argument_ordinal(); self.error_with_help( span, format!( @@ -2453,14 +2454,14 @@ impl Inferer<'_> { return Ok((TypedExprKind::Null, Type::Error)); } - let mut llm_schema = None; - if let Some(checked) = &checked_llm { - match self.llm_call_schema(checked, &result_ty, type_args_written, span) { - Ok(schema) => llm_schema = schema, + let mut emitted_schema = None; + if let Some(checked) = &schema_checked { + match self.schema_checked_call_schema(checked, &result_ty, type_args_written, span) { + Ok(schema) => emitted_schema = schema, Err(()) => return Ok((TypedExprKind::Null, Type::Error)), } } - if let Some(schema) = &llm_schema { + if let Some(schema) = &emitted_schema { self.substitute_schema_argument(¶ms, &mut typed_args, schema, span)?; } self.record_generic_call_arguments(&typed_args, ¶ms, &ret, type_args_written); @@ -2503,7 +2504,7 @@ impl Inferer<'_> { mangled, type_args: runtime_args, args: generic_args, - return_cast: if checked_get || checked_llm.is_some() { + return_cast: if checked_get || schema_checked.is_some() { None } else { return_cast @@ -2513,10 +2514,10 @@ impl Inferer<'_> { if checked_get { return self.checked_session_get(call, &result_ty, type_args_written, span); } - // An untyped `llm.call` emitted no schema and needs no check: it returns - // the `Completion` envelope the declaration already typed. - if checked_llm.is_some() && llm_schema.is_some() { - return self.checked_llm_cast(call, &result_ty, span); + // An untyped schema-checked call emitted no schema and needs no check: it + // returns the default the declaration already typed. + if schema_checked.is_some() && emitted_schema.is_some() { + return self.schema_checked_cast(call, &result_ty, span); } Ok((call, result_ty)) } diff --git a/crates/submilli-blueprint/src/auth_proxy.rs b/crates/submilli-blueprint/src/auth_proxy.rs index 94bbd14fd..0b9216c91 100644 --- a/crates/submilli-blueprint/src/auth_proxy.rs +++ b/crates/submilli-blueprint/src/auth_proxy.rs @@ -36,7 +36,8 @@ impl SecretResolver for DeclaredSecrets<'_> { } } -/// The first `auth_proxy` rule whose `host` matches exactly, with +/// [`submilli_policy::resolve_injections`] for a blueprint: the first +/// `auth_proxy` rule whose `host` matches exactly, with /// `${secrets.X}` resolved against the declared secrets. `Ok(None)` when no /// rule matches. pub async fn resolve_injections( @@ -51,10 +52,10 @@ pub async fn resolve_injections( submilli_policy::resolve_injections(&blueprint.auth_proxy, host, &secrets).await } -/// Replace every `${secrets.NAME}` in `value` with its resolved declared -/// secret. Public so other blueprint blocks that interpolate secrets (e.g. the -/// `mcp:` OAuth `client_id`) reuse the exact placeholder semantics `auth_proxy` -/// uses. +/// [`submilli_policy::interpolate`] for a blueprint: replace every +/// `${secrets.NAME}` in `value` with its resolved declared secret. Public so +/// other blueprint blocks that interpolate secrets (e.g. the `mcp:` OAuth +/// `client_id`) reuse the exact placeholder semantics `auth_proxy` uses. pub async fn interpolate( value: &str, blueprint: &Blueprint, diff --git a/crates/submilli-policy/src/lib.rs b/crates/submilli-policy/src/lib.rs index 9dc1256af..e75b195ff 100644 --- a/crates/submilli-policy/src/lib.rs +++ b/crates/submilli-policy/src/lib.rs @@ -24,8 +24,12 @@ pub use filter::{ }; pub use permissions::{ Action, DefaultAction, NearMiss, PermissionRule, Policy, Resolution, ResolutionCause, RuleRef, - Rules, explain, resolve, resolve_with_rule, + Rules, }; +/// The [`Policy`] methods over borrowed rules, for a format that keeps its rules +/// in place rather than building a `Policy`. +#[doc(hidden)] +pub use permissions::{explain, resolve, resolve_with_rule}; pub use variables::{VariableDecl, VariableError, resolve_variables}; /// Tooling over the filter language that is not part of the evaluation API: diff --git a/crates/submilli-policy/src/permissions.rs b/crates/submilli-policy/src/permissions.rs index 406b5d36d..c0a87cead 100644 --- a/crates/submilli-policy/src/permissions.rs +++ b/crates/submilli-policy/src/permissions.rs @@ -76,7 +76,9 @@ pub struct Policy { } impl Policy { - /// See [`resolve`]. + /// Walk the rules for `caller` and return the resolved action. No caller + /// block, or no rule matching `(capability, ctx)`, falls through to + /// `default`. pub fn resolve( &self, caller: &str, @@ -87,7 +89,8 @@ impl Policy { resolve(&self.rules, self.default, caller, capability, ctx, vars) } - /// See [`resolve_with_rule`]. + /// [`Self::resolve`], with the index of the deciding rule in the caller's + /// block, or `None` when the default decided. pub fn resolve_with_rule( &self, caller: &str, @@ -98,7 +101,8 @@ impl Policy { resolve_with_rule(&self.rules, self.default, caller, capability, ctx, vars) } - /// See [`explain`]. + /// [`Self::resolve`], with the reasoning: the deciding rule or default, and + /// the rules for the capability whose filters rejected the call. pub fn explain( &self, caller: &str, diff --git a/crates/submilli-shared/src/host.rs b/crates/submilli-shared/src/host.rs index f5a0ab91a..28f968a60 100644 --- a/crates/submilli-shared/src/host.rs +++ b/crates/submilli-shared/src/host.rs @@ -102,7 +102,8 @@ impl SourceSecretResolver for BlueprintSecretResolver { /// A blueprint's declared secrets as a policy [`SecretResolver`]: a name the /// `secrets:` block does not declare is undeclared, and a declared one resolves -/// from its source. +/// from its source. The owning form of [`DeclaredSecrets`], for the adapters +/// that keep a resolver for the life of a session. pub struct BlueprintSecrets { blueprint: Arc, resolver: BlueprintSecretResolver, diff --git a/docs/part-6-reference/standard-library.md b/docs/part-6-reference/standard-library.md index 07a52d42f..cb11ad8b2 100644 --- a/docs/part-6-reference/standard-library.md +++ b/docs/part-6-reference/standard-library.md @@ -7,7 +7,7 @@ sidebar: authorship: label: ai-assisted confirmed: true - contentHash: "3793fac8286c446ca61433ddc6b5f69445e64bf9b2ec0d36fb2c3e98b517179e" + contentHash: "94d4d49e52c6614b6be56c086abc7229f7c932d7d35e01e81c1e040b21c461f3" confirmedAt: "2026-10-09T15:40:52.000Z" --- @@ -213,17 +213,24 @@ listed by `submilli search` or in the sections below. - `run(agent, input)` returns the agent's final answer as text. With a type argument it works like `llm.call`: the schema for `T` is sent with the - task, and an answer that is not JSON or does not match `T` throws - `TypeError`. + task. An answer that is not JSON throws `SyntaxError`, and one that does + not match `T` throws `TypeError`. - The harness decides how long a run may take and what it may spend. The execution timeout does not stop a run in progress. - `list()` in either module leaves out what the policy denies the caller, without saying how many were left out. -- `readFile(name, path)` takes a path relative to the skill, with `/` - separators. An absolute path, or one with an empty, `.`, or `..` segment, - throws `RangeError`. Reading a file is gated by `skill.load` on the skill's - name. -- With no provider configured, every function throws an `Error` saying so. +- `load(name)` and `readFile(name, path)` take a skill name as `list()` + returns it. A name that is empty, `.` or `..`, or contains `/`, `\` or + NUL throws `RangeError`. +- `readFile` takes a path relative to the skill, with `/` separators. A path + that is absolute, has an empty, `.` or `..` segment, or contains `\`, `:` + or NUL throws `RangeError`. Reading a file is gated by `skill.load` on the + skill's name. +- A name or path over 4096 bytes of UTF-8 throws `RangeError`. +- A name may contain `:`, as in `plugin:review`. Policy rules match names + exactly as written: `Review` is not `review`. +- With no provider configured, any call the checks above allow throws an + `Error` saying so. diff --git a/plans/sub-1269-host-fuel-costs.md b/plans/sub-1269-host-fuel-costs.md index e4215e4fb..8916bb819 100644 --- a/plans/sub-1269-host-fuel-costs.md +++ b/plans/sub-1269-host-fuel-costs.md @@ -1834,8 +1834,8 @@ Optional: installed only for an embedder that enables it. Variables: `T` = bytes | Function | What the host does | Formula | Charge point | Notes | |---|---|---|---|---| | `submilli:skills#list` | Gate, list the skills, run the policy check once per skill, sanitize each description, build `SkillInfo` structs and an array (`stdlib/skills/mod.rs` `list`) | `CALL + (1 + m) x GATE + ELEM(m)` plus the strings through `write_submilli_string_struct` | before + output | `m` is known after `provider.list().await`. | -| `submilli:skills#load` | Gate, one provider read, build the `Skill` struct (`stdlib/skills/mod.rs` `load`) | `CALL + GATE + IO(T)` plus the strings through `write_submilli_string_struct` | `IO(T)` and the result after the read | The read is the effect, so the result is built under `settle_result`. | -| `submilli:skills#readFile` | Gate, check the path, one provider read, build the string (`stdlib/skills/mod.rs` `read_file`) | `CALL + GATE + IO(T)` plus the string through `write_submilli_string_struct` | `IO(T)` and the result after the read | A path outside the skill is refused before the provider is asked. | +| `submilli:skills#load` | Gate, check the name, one provider read, build the `Skill` struct (`stdlib/skills/mod.rs` `load`) | `CALL + GATE + IO(T)` plus the strings through `write_submilli_string_struct` | `IO(T)` and the result after the read | The read is the effect, so the result is built under `settle_result`. A name that is not one skill name is refused before the provider is asked. | +| `submilli:skills#readFile` | Gate, check the name and the path, one provider read, build the string (`stdlib/skills/mod.rs` `read_file`) | `CALL + GATE + IO(T)` plus the string through `write_submilli_string_struct` | `IO(T)` and the result after the read | A name or path outside the skills is refused before the provider is asked. | | `submilli:skills#Skill#content` | Field read | `CALL` | before | | | `submilli:skills#Skill#description` | Field read | `CALL` | before | | | `submilli:skills#Skill#name` | Field read | `CALL` | before | | From 3f83c119bda5406013aa665b37fc26856c7d3997 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 19:12:29 +0300 Subject: [PATCH 07/10] Move the engine to crates/submilli-engine and fix a misplaced doc comment The directory now matches the crate name. Resolve permission's doc comment had been stacked on resolve_permission_with_rule; it is back on its function. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 6 +++--- Cargo.toml | 2 +- crates/conformance/Cargo.toml | 2 +- crates/conformance/typescript/README.md | 2 +- ...at_definition__tests__function_renders_arrow_form.snap | 5 ----- ...ition__tests__interface_renders_optional_property.snap | 7 ------- ...t_definition__tests__interface_renders_properties.snap | 8 -------- ...on__tests__interface_substitutes_property_generic.snap | 7 ------- ...efinition__tests__object_renders_structural_shape.snap | 8 -------- ...efinition__tests__primitive_with_declared_methods.snap | 7 ------- ...cker__infer__type_diff__tests__object_extra_field.snap | 5 ----- ...er__infer__type_diff__tests__object_missing_field.snap | 5 ----- crates/submilli-blueprint/src/lib.rs | 8 ++++---- crates/submilli-build/Cargo.toml | 2 +- crates/{interpreter => submilli-engine}/Cargo.toml | 0 crates/{interpreter => submilli-engine}/README.md | 0 crates/{interpreter => submilli-engine}/build.rs | 0 crates/{interpreter => submilli-engine}/src/arena.rs | 0 .../{interpreter => submilli-engine}/src/artifact_f64.rs | 0 crates/{interpreter => submilli-engine}/src/asi.rs | 0 crates/{interpreter => submilli-engine}/src/ast.rs | 0 crates/{interpreter => submilli-engine}/src/authority.rs | 0 crates/{interpreter => submilli-engine}/src/backtrace.rs | 0 .../src/capability_derivation.rs | 0 .../src/codegen/analysis.rs | 0 .../src/codegen/argument_defaults.rs | 0 .../src/codegen/bigint_pool.rs | 0 .../src/codegen/bounds.rs | 0 .../src/codegen/box_types.rs | 0 .../src/codegen/call_arguments.rs | 0 .../src/codegen/cast_check.rs | 0 .../src/codegen/cast_diagnostics.rs | 0 .../src/codegen/classes.rs | 0 .../src/codegen/closure_coercions.rs | 0 .../src/codegen/closures.rs | 0 .../src/codegen/dependency_usage.rs | 0 .../{interpreter => submilli-engine}/src/codegen/dwarf.rs | 0 .../src/codegen/field_guards.rs | 0 .../src/codegen/field_lookup.rs | 0 .../src/codegen/field_name_strings.rs | 0 .../src/codegen/field_names.rs | 0 .../src/codegen/function_adapters.rs | 0 .../src/codegen/function_emitter/binding_cells.rs | 0 .../src/codegen/function_emitter/cast.rs | 0 .../src/codegen/function_emitter/expr.rs | 0 .../src/codegen/function_emitter/finally.rs | 0 .../src/codegen/function_emitter/json.rs | 0 .../src/codegen/function_emitter/mcp.rs | 0 .../src/codegen/function_emitter/mod.rs | 0 .../src/codegen/function_emitter/stmt.rs | 0 .../src/codegen/imported_classes.rs | 0 .../src/codegen/init_guard.rs | 0 .../src/codegen/intrinsics.rs | 0 .../src/codegen/invariant_tests.rs | 0 .../{interpreter => submilli-engine}/src/codegen/mod.rs | 0 .../src/codegen/nullish.rs | 0 .../src/codegen/recursive_validators.rs | 0 .../src/codegen/runtime_descriptors.rs | 0 .../src/codegen/runtime_values.rs | 0 .../src/codegen/runtime_values/declarations.rs | 0 .../src/codegen/runtime_values/flow.rs | 0 .../src/codegen/runtime_values/rewrite.rs | 0 ...odegen__tests__assert_false_throws_with_backtrace.snap | 2 +- ..._method_accessor_and_constructor_frames_are_named.snap | 2 +- ...s__code_after_a_cast_keeps_its_backtrace_location.snap | 2 +- ...bmilli_engine__codegen__tests__dwarf_die_snapshot.snap | 2 +- ..._codegen__tests__dwarf_line_program_covers_helper.snap | 2 +- ...gine__codegen__tests__dwarf_line_program_snapshot.snap | 2 +- ...__tests__dwarf_subprograms_for_each_user_function.snap | 2 +- ...__tests__failed_cast_backtrace_points_at_the_cast.snap | 2 +- ...lli_engine__codegen__tests__multi_frame_backtrace.snap | 2 +- ...ts__three_frame_backtrace_labels_caller_in_middle.snap | 2 +- .../src/codegen/string_pool.rs | 0 .../src/codegen/symbol_table.rs | 0 .../src/codegen/this_binding.rs | 0 .../{interpreter => submilli-engine}/src/codegen/throw.rs | 0 .../src/codegen/user_subtypes.rs | 0 .../src/codegen/vtable_walk.rs | 0 crates/{interpreter => submilli-engine}/src/compile.rs | 0 .../src/compile_capabilities.rs | 0 .../src/compiler_error.rs | 0 .../src/compiler_limits.rs | 0 .../{interpreter => submilli-engine}/src/diagnostics.rs | 0 .../{interpreter => submilli-engine}/src/did_you_mean.rs | 0 .../{interpreter => submilli-engine}/src/doc_comment.rs | 0 crates/{interpreter => submilli-engine}/src/lexer.rs | 0 crates/{interpreter => submilli-engine}/src/lib.rs | 0 .../{interpreter => submilli-engine}/src/literal_units.rs | 0 .../src/lower_patterns.rs | 0 crates/{interpreter => submilli-engine}/src/mangle.rs | 0 .../src/package_declaration.rs | 0 crates/{interpreter => submilli-engine}/src/packages.rs | 0 crates/{interpreter => submilli-engine}/src/parser.rs | 0 crates/{interpreter => submilli-engine}/src/rendering.rs | 0 .../src/runtime/agents.rs | 0 .../src/runtime/array_storage.rs | 0 .../src/runtime/blocking.rs | 0 .../src/runtime/call_log.rs | 0 .../src/runtime/decision.rs | 0 .../src/runtime/disk_quota.rs | 0 .../src/runtime/embedding.rs | 0 .../{interpreter => submilli-engine}/src/runtime/exec.rs | 0 crates/{interpreter => submilli-engine}/src/runtime/fs.rs | 0 .../src/runtime/fs/removal.rs | 0 .../{interpreter => submilli-engine}/src/runtime/fuel.rs | 0 .../src/runtime/gc_singleton.rs | 0 .../{interpreter => submilli-engine}/src/runtime/host.rs | 0 .../src/runtime/intrinsic_types.rs | 0 .../{interpreter => submilli-engine}/src/runtime/json.rs | 0 .../src/runtime/json/format.rs | 0 .../src/runtime/json_text.rs | 0 .../src/runtime/limits.rs | 0 .../{interpreter => submilli-engine}/src/runtime/llm.rs | 0 .../{interpreter => submilli-engine}/src/runtime/mcp.rs | 0 .../src/runtime/mcp/response.rs | 0 .../src/runtime/metrics.rs | 0 .../{interpreter => submilli-engine}/src/runtime/mod.rs | 0 .../src/runtime/number.rs | 0 .../src/runtime/prelude/arguments.rs | 0 .../src/runtime/prelude/array/install.rs | 0 .../src/runtime/prelude/array/mod.rs | 0 .../src/runtime/prelude/array/sort.rs | 0 .../src/runtime/prelude/bigint/mod.rs | 0 .../src/runtime/prelude/bigint/ops.rs | 0 .../src/runtime/prelude/bitwise.rs | 0 .../src/runtime/prelude/boolean/mod.rs | 0 .../src/runtime/prelude/closure.rs | 0 .../src/runtime/prelude/collection.rs | 0 .../src/runtime/prelude/console.rs | 0 .../src/runtime/prelude/declaration.rs | 0 .../src/runtime/prelude/error.rs | 0 .../src/runtime/prelude/iterator/mod.rs | 0 .../src/runtime/prelude/keep.rs | 0 .../src/runtime/prelude/ledger.rs | 0 .../src/runtime/prelude/map/install.rs | 0 .../src/runtime/prelude/map/mod.rs | 0 .../src/runtime/prelude/math.rs | 0 .../src/runtime/prelude/member.rs | 0 .../src/runtime/prelude/mod.rs | 0 .../src/runtime/prelude/number/mod.rs | 0 .../src/runtime/prelude/object/dynamic.rs | 0 .../src/runtime/prelude/object/index.rs | 0 .../src/runtime/prelude/object/mod.rs | 0 .../src/runtime/prelude/object/static_value.rs | 0 .../src/runtime/prelude/regex/engine.rs | 0 .../src/runtime/prelude/regex/input.rs | 0 .../src/runtime/prelude/regex/install.rs | 0 .../src/runtime/prelude/regex/mod.rs | 0 .../src/runtime/prelude/regex/output.rs | 0 .../src/runtime/prelude/set/install.rs | 0 .../src/runtime/prelude/set/mod.rs | 0 .../src/runtime/prelude/string/install.rs | 0 .../src/runtime/prelude/string/mod.rs | 0 .../src/runtime/prelude/string/search.rs | 0 .../src/runtime/prelude/string/transforms.rs | 0 .../src/runtime/prelude/temporal/duration/install.rs | 0 .../src/runtime/prelude/temporal/duration/mod.rs | 0 .../src/runtime/prelude/temporal/instant/install.rs | 0 .../src/runtime/prelude/temporal/instant/mod.rs | 0 .../src/runtime/prelude/temporal/mod.rs | 0 .../src/runtime/prelude/temporal/now/install.rs | 0 .../src/runtime/prelude/temporal/now/mod.rs | 0 .../src/runtime/prelude/temporal/plain_date/install.rs | 0 .../src/runtime/prelude/temporal/plain_date/mod.rs | 0 .../runtime/prelude/temporal/plain_date_time/install.rs | 0 .../src/runtime/prelude/temporal/plain_date_time/mod.rs | 0 .../runtime/prelude/temporal/plain_month_day/install.rs | 0 .../src/runtime/prelude/temporal/plain_month_day/mod.rs | 0 .../src/runtime/prelude/temporal/plain_time/install.rs | 0 .../src/runtime/prelude/temporal/plain_time/mod.rs | 0 .../runtime/prelude/temporal/plain_year_month/install.rs | 0 .../src/runtime/prelude/temporal/plain_year_month/mod.rs | 0 .../src/runtime/prelude/temporal/shared.rs | 0 .../runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE | 0 .../runtime/prelude/temporal/zoned_date_time/install.rs | 0 .../src/runtime/prelude/temporal/zoned_date_time/mod.rs | 0 .../prelude/temporal/zoned_date_time/zone_cache.rs | 0 .../runtime/prelude/temporal/zoned_date_time/zone_ids.rs | 0 .../src/runtime/prelude/textcodec/install.rs | 0 .../src/runtime/prelude/textcodec/mod.rs | 0 .../src/runtime/prelude/uint8array/install.rs | 0 .../src/runtime/prelude/uint8array/mod.rs | 0 .../src/runtime/prelude/undefined.rs | 0 .../src/runtime/prelude/uri.rs | 0 .../src/runtime/prelude/value.rs | 0 .../src/runtime/prelude/vtable.rs | 0 .../src/runtime/prelude/vtable/serialization.rs | 0 .../src/runtime/secrets.rs | 0 .../src/runtime/security.rs | 0 .../src/runtime/session_kv.rs | 0 .../src/runtime/skills.rs | 0 .../src/runtime/token_ledger.rs | 0 .../{interpreter => submilli-engine}/src/runtime/vfs.rs | 0 .../src/runtime/watchdog.rs | 0 crates/{interpreter => submilli-engine}/src/shape.rs | 0 ...submilli_engine__asi__tests__mvp_fixture_snapshot.snap | 2 +- ..._engine__diagnostics__tests__render_clamps_at_eof.snap | 2 +- ..._engine__diagnostics__tests__render_clamps_at_sof.snap | 2 +- ...ts__render_multi_note_error_with_gutter_alignment.snap | 2 +- ..._diagnostics__tests__render_multiline_span_carets.snap | 2 +- ...engine__diagnostics__tests__render_multiple_helps.snap | 2 +- ...ine__diagnostics__tests__render_single_line_error.snap | 2 +- ...gine__diagnostics__tests__render_warning_severity.snap | 2 +- ...illi_engine__diagnostics__tests__render_with_help.snap | 2 +- ...e__diagnostics__tests__render_with_help_and_notes.snap | 2 +- ...iagnostics__tests__render_zero_length_span_at_eof.snap | 2 +- ...e__lexer__tests__renders_bare_exponent_diagnostic.snap | 2 +- ...er__tests__renders_unterminated_string_diagnostic.snap | 2 +- ...__tests__renders_unterminated_template_diagnostic.snap | 2 +- ...bmilli_engine__lexer__tests__tokenize_mvp_fixture.snap | 2 +- ...ne__parser__tests__full_precedence_chain_snapshot.snap | 2 +- ...li_engine__parser__tests__parse_sequence_of_atoms.snap | 2 +- ...lli_engine__parser__tests__snapshot_else_if_chain.snap | 2 +- ...ine__parser__tests__snapshot_function_declaration.snap | 2 +- ...rser__tests__snapshot_function_with_if_and_return.snap | 2 +- ...gine__parser__tests__snapshot_function_with_while.snap | 2 +- ...ngine__parser__tests__snapshot_mixed_declarations.snap | 2 +- ...ngine__parser__tests__snapshot_multi_call_program.snap | 2 +- ...ngine__parser__tests__snapshot_multi_error_render.snap | 2 +- ...parser__tests__snapshot_object_and_array_literals.snap | 2 +- ...li_engine__parser__tests__snapshot_union_type_mix.snap | 2 +- crates/{interpreter => submilli-engine}/src/source.rs | 0 .../src/source_validation.rs | 0 crates/{interpreter => submilli-engine}/src/span.rs | 0 crates/{interpreter => submilli-engine}/src/stdlib/abi.rs | 0 .../src/stdlib/agents/declaration.rs | 0 .../src/stdlib/agents/mod.rs | 0 .../src/stdlib/capabilities.rs | 0 .../src/stdlib/code/budget.rs | 0 .../src/stdlib/code/declaration.rs | 0 .../src/stdlib/code/mod.rs | 0 .../src/stdlib/code/myers.rs | 0 .../src/stdlib/code/patch.rs | 0 .../src/stdlib/code/tests.rs | 0 .../src/stdlib/code/text.rs | 0 .../src/stdlib/code/walk.rs | 0 .../{interpreter => submilli-engine}/src/stdlib/crypto.rs | 0 .../src/stdlib/dot_segments.rs | 0 .../src/stdlib/embedding/declaration.rs | 0 .../src/stdlib/embedding/mod.rs | 0 .../src/stdlib/fs/declaration.rs | 0 .../src/stdlib/fs/handles.rs | 0 .../{interpreter => submilli-engine}/src/stdlib/fs/mod.rs | 0 .../src/stdlib/git/class.rs | 0 .../src/stdlib/git/declaration.rs | 0 .../src/stdlib/git/diff.rs | 0 .../src/stdlib/git/history.rs | 0 .../src/stdlib/git/index_limits.rs | 0 .../src/stdlib/git/integration_tests.rs | 0 .../src/stdlib/git/location.rs | 0 .../src/stdlib/git/lock.rs | 0 .../src/stdlib/git/log_cache.rs | 0 .../src/stdlib/git/metadata_scan.rs | 0 .../src/stdlib/git/meter.rs | 0 .../src/stdlib/git/mod.rs | 0 .../src/stdlib/git/object.rs | 0 .../src/stdlib/git/operations.rs | 0 .../src/stdlib/git/pack_index_check.rs | 0 .../src/stdlib/git/pack_limits.rs | 0 .../src/stdlib/git/stage.rs | 0 .../src/stdlib/git/storage.rs | 0 .../src/stdlib/git/tests.rs | 0 .../src/stdlib/git/transport.rs | 0 .../src/stdlib/git/work.rs | 0 .../src/stdlib/git/worker.rs | 0 .../src/stdlib/http/declaration.rs | 0 .../src/stdlib/http/mod.rs | 0 .../src/stdlib/http/policy.rs | 0 .../src/stdlib/http/redirect_guard.rs | 0 .../src/stdlib/http/transport.rs | 0 .../src/stdlib/http/transport_policy.rs | 0 .../src/stdlib/http/transport_policy_tests.rs | 0 .../src/stdlib/http/transport_tls_tests.rs | 0 .../src/stdlib/llm/declaration.rs | 0 .../src/stdlib/llm/mod.rs | 0 crates/{interpreter => submilli-engine}/src/stdlib/mod.rs | 0 .../src/stdlib/optional_tests.rs | 0 .../src/stdlib/secrets.rs | 0 .../src/stdlib/security.rs | 0 .../src/stdlib/session/cursor.rs | 0 .../src/stdlib/session/declaration.rs | 0 .../src/stdlib/session/mod.rs | 0 .../src/stdlib/session/value.rs | 0 .../{interpreter => submilli-engine}/src/stdlib/shared.rs | 0 .../src/stdlib/skills/declaration.rs | 0 .../src/stdlib/skills/mod.rs | 0 .../{interpreter => submilli-engine}/src/stdlib/test.rs | 0 crates/{interpreter => submilli-engine}/src/stdlib/url.rs | 0 .../{interpreter => submilli-engine}/src/stdlib/uuid.rs | 0 crates/{interpreter => submilli-engine}/src/token.rs | 0 .../{interpreter => submilli-engine}/src/tree_height.rs | 0 crates/{interpreter => submilli-engine}/src/type_info.rs | 0 .../src/type_rendering.rs | 0 crates/{interpreter => submilli-engine}/src/type_size.rs | 0 crates/{interpreter => submilli-engine}/src/type_walk.rs | 0 .../src/typechecker/capture.rs | 0 .../src/typechecker/desugar/do_while.rs | 0 .../src/typechecker/desugar/for_loop.rs | 0 .../src/typechecker/desugar/for_of.rs | 0 .../src/typechecker/desugar/mod.rs | 0 .../src/typechecker/desugar/postfix_incdec.rs | 0 .../src/typechecker/infer/aliased_conditions.rs | 0 .../src/typechecker/infer/assign_expr.rs | 0 .../src/typechecker/infer/assignable.rs | 0 .../src/typechecker/infer/best_common_type.rs | 0 .../src/typechecker/infer/binding_analysis.rs | 0 .../src/typechecker/infer/classes.rs | 0 .../src/typechecker/infer/closure_arity.rs | 0 .../src/typechecker/infer/comparable.rs | 0 .../src/typechecker/infer/comparison_operand.rs | 0 .../src/typechecker/infer/diagnostics.rs | 0 .../src/typechecker/infer/enums.rs | 0 .../src/typechecker/infer/exports.rs | 0 .../src/typechecker/infer/expr.rs | 0 .../src/typechecker/infer/format_definition.rs | 0 .../src/typechecker/infer/format_signature.rs | 0 .../src/typechecker/infer/forward_globals.rs | 0 .../src/typechecker/infer/generic.rs | 0 .../src/typechecker/infer/generic_scopes.rs | 0 .../src/typechecker/infer/globals.rs | 0 .../src/typechecker/infer/iife.rs | 0 .../src/typechecker/infer/import_graph.rs | 0 .../src/typechecker/infer/imports.rs | 0 .../src/typechecker/infer/inference_sources.rs | 0 .../src/typechecker/infer/literal_freshness.rs | 0 .../src/typechecker/infer/lookup.rs | 0 .../src/typechecker/infer/mod.rs | 0 .../src/typechecker/infer/module_symbols.rs | 0 .../src/typechecker/infer/namespace_symbol.rs | 0 .../src/typechecker/infer/narrow_scopes.rs | 0 .../src/typechecker/infer/narrowing.rs | 0 .../src/typechecker/infer/nested_functions.rs | 0 .../src/typechecker/infer/object_normalization.rs | 0 .../src/typechecker/infer/param_defaults.rs | 0 .../src/typechecker/infer/predicate_envs.rs | 0 .../src/typechecker/infer/records.rs | 0 .../src/typechecker/infer/reserved.rs | 0 .../src/typechecker/infer/resolve_type.rs | 0 .../src/typechecker/infer/scopes.rs | 0 .../src/typechecker/infer/shapes.rs | 0 .../src/typechecker/infer/signatures.rs | 0 ...ecker__infer__expr__tests__snapshot_mixed_program.snap | 2 +- ...ition__tests__array_substitutes_interface_generic.snap | 2 +- ...at_definition__tests__function_renders_arrow_form.snap | 5 +++++ ...n__tests__interface_ref_substitutes_multiple_args.snap | 2 +- ...ition__tests__interface_renders_optional_property.snap | 7 +++++++ ...t_definition__tests__interface_renders_properties.snap | 8 ++++++++ ...on__tests__interface_substitutes_property_generic.snap | 7 +++++++ ...efinition__tests__object_renders_structural_shape.snap | 8 ++++++++ ...efinition__tests__primitive_with_declared_methods.snap | 7 +++++++ ...ker__infer__type_diff__tests__function_arity_diff.snap | 2 +- ...diff__tests__function_combined_arity_param_return.snap | 2 +- ...infer__type_diff__tests__function_param_type_diff.snap | 2 +- ...nfer__type_diff__tests__function_return_type_diff.snap | 2 +- ...er__type_diff__tests__object_all_three_dimensions.snap | 2 +- ...cker__infer__type_diff__tests__object_extra_field.snap | 5 +++++ ...fer__type_diff__tests__object_field_type_mismatch.snap | 2 +- ...er__infer__type_diff__tests__object_missing_field.snap | 5 +++++ .../src/typechecker/infer/stmt.rs | 0 .../src/typechecker/infer/switch_stmt.rs | 0 .../src/typechecker/infer/test_support.rs | 0 .../src/typechecker/infer/type_aliases.rs | 0 .../src/typechecker/infer/type_diff.rs | 0 .../src/typechecker/infer/type_namespace.rs | 0 .../src/typechecker/infer/type_predicate.rs | 0 .../src/typechecker/infer/type_registry.rs | 0 .../src/typechecker/infer/value_operand.rs | 0 .../src/typechecker/infer/variance.rs | 0 .../src/typechecker/json_schema.rs | 0 .../src/typechecker/json_strategy.rs | 0 .../src/typechecker/mod.rs | 0 .../src/typechecker/rules/body_walk.rs | 0 .../src/typechecker/rules/capability_consistency.rs | 0 .../src/typechecker/rules/check_calls.rs | 0 .../src/typechecker/rules/check_discipline/bodies.rs | 0 .../src/typechecker/rules/check_discipline/checked.rs | 0 .../src/typechecker/rules/check_discipline/findings.rs | 0 .../src/typechecker/rules/check_discipline/flow.rs | 0 .../src/typechecker/rules/check_discipline/mod.rs | 0 .../src/typechecker/rules/check_discipline/origin.rs | 0 .../src/typechecker/rules/check_discipline/package.rs | 0 .../src/typechecker/rules/check_discipline/scope.rs | 0 .../src/typechecker/rules/check_discipline/stability.rs | 0 .../src/typechecker/rules/check_discipline/tests.rs | 0 .../src/typechecker/rules/control_flow.rs | 0 .../src/typechecker/rules/declarations.rs | 0 .../src/typechecker/rules/definite_assignment.rs | 0 .../src/typechecker/rules/doc_consistency.rs | 0 .../src/typechecker/rules/exported_docs.rs | 0 .../src/typechecker/rules/exported_signature_types.rs | 0 .../src/typechecker/rules/fallthrough.rs | 0 .../src/typechecker/rules/main_required.rs | 0 .../src/typechecker/rules/missing_return.rs | 0 .../src/typechecker/rules/mod.rs | 0 .../src/typechecker/rules/return_outside_function.rs | 0 .../src/typechecker/rules/super_call.rs | 0 .../src/typechecker/rules/unreachable.rs | 0 .../src/typechecker/type_param_substitution.rs | 0 crates/{interpreter => submilli-engine}/src/typed_ast.rs | 0 crates/{interpreter => submilli-engine}/src/types.rs | 0 .../tests/checked_arena.rs | 0 .../tests/checked_rendering.rs | 0 .../tests/checked_source.rs | 0 .../tests/checked_typed_phases.rs | 0 .../tests/checked_untyped_phases.rs | 0 .../tests/class_rec_group.rs | 0 .../tests/closure_arity.rs | 0 .../tests/closure_arity_diagnostics.rs | 0 .../tests/closure_lowering_errors.rs | 0 .../tests/compiler_structure_limits.rs | 0 .../tests/console_failure.rs | 0 .../tests/cross_module_gc_types.rs | 0 .../tests/decision_records.rs | 0 .../{interpreter => submilli-engine}/tests/determinism.rs | 0 .../tests/diagnostic_snapshots.rs | 0 .../tests/field_lookup_size.rs | 0 crates/{interpreter => submilli-engine}/tests/fixtures.rs | 0 .../tests/fixtures/alias_index_read_write.ts | 0 .../tests/fixtures/alias_peel_dispatch.ts | 0 .../tests/fixtures/angle_bracket_cast.ts | 0 .../tests/fixtures/array_at.subm | 0 .../tests/fixtures/array_callback_truthiness.ts | 0 .../tests/fixtures/array_concat.subm | 0 .../tests/fixtures/array_copy_within.subm | 0 .../tests/fixtures/array_every.subm | 0 .../tests/fixtures/array_fill.subm | 0 .../tests/fixtures/array_filter.subm | 0 .../tests/fixtures/array_filter_guard_narrows_to_class.ts | 0 .../tests/fixtures/array_filter_type_guard_narrows.ts | 0 .../tests/fixtures/array_find.subm | 0 .../tests/fixtures/array_findindex.subm | 0 .../tests/fixtures/array_flat.subm | 0 .../tests/fixtures/array_flat_depth_budget.ts | 0 .../tests/fixtures/array_flat_depth_error.subm | 0 .../tests/fixtures/array_flatmap.subm | 0 .../tests/fixtures/array_for_each.subm | 0 .../tests/fixtures/array_from.subm | 0 .../tests/fixtures/array_from_array_like_length.ts | 0 .../tests/fixtures/array_from_array_like_wider_source.ts | 0 .../tests/fixtures/array_from_collections.ts | 0 .../tests/fixtures/array_generic_spelling.subm | 0 .../tests/fixtures/array_host_port_edges.ts | 0 .../tests/fixtures/array_includes.subm | 0 .../tests/fixtures/array_index_domain.ts | 0 .../tests/fixtures/array_index_of.subm | 0 .../tests/fixtures/array_index_oob_throws.subm | 0 .../tests/fixtures/array_indexed_write_rhs_grows.ts | 0 .../tests/fixtures/array_iter_next_result.ts | 0 .../tests/fixtures/array_join.subm | 0 .../tests/fixtures/array_join_null.ts | 0 .../tests/fixtures/array_keeps_regular_literal_types.ts | 0 .../tests/fixtures/array_keys_values_entries.subm | 0 .../tests/fixtures/array_last_index_of.subm | 0 .../tests/fixtures/array_length.subm | 0 .../tests/fixtures/array_like_union_reads.ts | 0 .../tests/fixtures/array_like_union_writes.ts | 0 .../tests/fixtures/array_literal_best_common_type.ts | 0 .../tests/fixtures/array_literal_element_order.ts | 0 .../fixtures/array_literal_normalized_to_optional.ts | 0 .../tests/fixtures/array_literal_object_normalization.ts | 0 .../array_literal_object_normalization_fresh_only.ts | 0 .../tests/fixtures/array_literal_union_of_arrays.ts | 0 .../fixtures/array_literal_union_of_arrays_mismatch.ts | 0 .../tests/fixtures/array_literal_wider_element.ts | 0 .../fixtures/array_literal_wider_element_mismatch.ts | 0 .../tests/fixtures/array_map.subm | 0 .../tests/fixtures/array_of.subm | 0 .../fixtures/array_of_object_literal_arrays_union.ts | 0 .../tests/fixtures/array_pop.subm | 0 .../tests/fixtures/array_push.subm | 0 .../tests/fixtures/array_reduce.subm | 0 .../tests/fixtures/array_reduce_right.subm | 0 .../tests/fixtures/array_reverse.subm | 0 .../tests/fixtures/array_shift_unshift.subm | 0 .../tests/fixtures/array_slice.subm | 0 .../tests/fixtures/array_some.subm | 0 .../tests/fixtures/array_sort.subm | 0 .../tests/fixtures/array_sort_cached_units.ts | 0 .../tests/fixtures/array_sort_keeps_comparator_pushes.ts | 0 .../tests/fixtures/array_sort_stable_merge.ts | 0 .../tests/fixtures/array_splice.subm | 0 .../tests/fixtures/array_spread_parameter.ts | 0 .../tests/fixtures/array_to_reversed.subm | 0 .../tests/fixtures/array_to_sorted.subm | 0 .../tests/fixtures/array_to_spliced.subm | 0 .../tests/fixtures/array_values_host_iter.ts | 0 .../tests/fixtures/array_with.subm | 0 .../tests/fixtures/arrow_return_type_forms.ts | 0 .../tests/fixtures/asi_allman_braces.ts | 0 .../tests/fixtures/asi_clause_and_arrow_wraps.ts | 0 .../tests/fixtures/asi_keyword_members.ts | 0 .../tests/fixtures/asi_line_break_after_as_type.ts | 0 .../tests/fixtures/asi_line_wrapped_operators.subm | 0 .../tests/fixtures/asi_statement_ends_at_closing_brace.ts | 0 .../tests/fixtures/asi_template_substitution_wraps.ts | 0 .../tests/fixtures/asi_type_members_in_brackets.ts | 0 .../tests/fixtures/assert_pass.subm | 0 .../tests/fixtures/assert_throws_catchable.subm | 0 .../tests/fixtures/assignment_expression.ts | 0 .../tests/fixtures/assignment_keeps_literal_types.ts | 0 .../fixtures/assignment_narrows_to_declared_member.ts | 0 .../tests/fixtures/bare_return_in_inferred_closure.ts | 0 .../tests/fixtures/bigint_arithmetic.subm | 0 .../tests/fixtures/bigint_compare.subm | 0 .../tests/fixtures/bigint_container_equality.subm | 0 .../tests/fixtures/bigint_conversions.subm | 0 .../tests/fixtures/bigint_decimal_budget.ts | 0 .../tests/fixtures/bigint_float_literal.subm | 0 .../tests/fixtures/bigint_join.subm | 0 .../tests/fixtures/bigint_large_literal.subm | 0 .../tests/fixtures/bigint_literal_basic.subm | 0 .../tests/fixtures/bigint_literal_narrowing.ts | 0 .../tests/fixtures/bigint_literal_types.ts | 0 .../tests/fixtures/bigint_namespace_typo.subm | 0 .../tests/fixtures/bigint_number_exact.ts | 0 .../tests/fixtures/bigint_plus_number.subm | 0 .../tests/fixtures/bigint_to_json.ts | 0 .../tests/fixtures/bigint_to_string_radix.subm | 0 .../tests/fixtures/bind_void_call_value.ts | 0 .../tests/fixtures/binding_scope/calls.ts | 0 .../tests/fixtures/binding_scope/capture_block_shadow.ts | 0 .../tests/fixtures/binding_scope/captured_write.ts | 0 .../tests/fixtures/binding_scope/early_assignment.ts | 0 .../tests/fixtures/binding_scope/early_namespace.ts | 0 .../tests/fixtures/binding_scope/for_of_pattern_shadow.ts | 0 .../tests/fixtures/binding_scope/for_of_pattern_tdz.ts | 0 .../tests/fixtures/binding_scope/for_of_tdz.ts | 0 .../tests/fixtures/binding_scope/hygiene.ts | 0 .../tests/fixtures/binding_scope/hygiene_array.ts | 0 .../tests/fixtures/binding_scope/hygiene_iterator.ts | 0 .../tests/fixtures/binding_scope/intrinsic.ts | 0 .../tests/fixtures/binding_scope/mutators.ts | 0 .../tests/fixtures/binding_scope/namespace.ts | 0 .../tests/fixtures/binding_scope/parseint_required_arg.ts | 0 .../tests/fixtures/binding_scope/pattern_hygiene.ts | 0 .../tests/fixtures/binding_scope/redeclare.ts | 0 .../tests/fixtures/binding_scope/redeclare_catch.ts | 0 .../tests/fixtures/binding_scope/redeclare_let.ts | 0 .../tests/fixtures/binding_scope/redeclare_param.ts | 0 .../tests/fixtures/binding_scope/redeclare_pattern.ts | 0 .../tests/fixtures/binding_scope/redeclare_rest.ts | 0 .../tests/fixtures/binding_scope/self_initialization.ts | 0 .../tests/fixtures/binding_scope/shadowing.ts | 0 .../tests/fixtures/binding_scope/tdz.ts | 0 .../tests/fixtures/bitwise/asi.ts | 0 .../tests/fixtures/bitwise/assignments.ts | 0 .../tests/fixtures/bitwise/bigints.ts | 0 .../tests/fixtures/bitwise/coercion.ts | 0 .../tests/fixtures/bitwise/evaluation.ts | 0 .../tests/fixtures/bitwise/generics.ts | 0 .../tests/fixtures/bitwise/invalid.ts | 0 .../tests/fixtures/bitwise/invalid_unary.ts | 0 .../tests/fixtures/bitwise/live_values.ts | 0 .../tests/fixtures/bitwise/numbers.ts | 0 .../tests/fixtures/boolean_literal_types.ts | 0 .../tests/fixtures/boxed_primitive_vtables.ts | 0 .../tests/fixtures/braceless_bodies_accepted.ts | 0 .../tests/fixtures/braceless_control_bodies.subm | 0 .../tests/fixtures/builtin_error.subm | 0 .../tests/fixtures/bulk_string_and_byte_copies.ts | 0 .../tests/fixtures/call_sig_number_from_string.subm | 0 .../tests/fixtures/call_sig_string_coercion.subm | 0 .../tests/fixtures/call_sig_user_interface.subm | 0 .../tests/fixtures/captured_let_same_frame_reassign.subm | 0 .../tests/fixtures/cast_and_spread_object_literals.ts | 0 .../tests/fixtures/cast_rest_function_to_fixed_arity.ts | 0 .../tests/fixtures/cast_self_nominal_interface.ts | 0 .../tests/fixtures/cast_to_union_member_overlap.ts | 0 .../tests/fixtures/cast_void_adapter_to_value_function.ts | 0 .../tests/fixtures/casts/as_array_element_check.subm | 0 .../tests/fixtures/casts/as_chain_round_trip.subm | 0 .../tests/fixtures/casts/as_enum_target.ts | 0 .../fixtures/casts/as_interface_non_object_throws.subm | 0 .../tests/fixtures/casts/as_nested_and_optional.subm | 0 .../tests/fixtures/casts/as_number_passthrough.subm | 0 .../tests/fixtures/casts/as_object_literal_field.subm | 0 .../tests/fixtures/casts/as_proven_upcast_no_check.subm | 0 .../tests/fixtures/casts/as_recursive_object.subm | 0 .../tests/fixtures/casts/as_recursive_union.subm | 0 .../tests/fixtures/casts/as_string_passthrough.subm | 0 .../tests/fixtures/casts/as_union_to_member.subm | 0 .../tests/fixtures/casts/as_unknown_to_interface.subm | 0 .../tests/fixtures/casts/as_unknown_to_object_shape.subm | 0 .../casts/expect_error_incompatible_static_cast.subm | 0 .../casts/expect_error_object_to_unrelated_interface.subm | 0 .../tests/fixtures/casts/issue_905_paths.ts | 0 .../tests/fixtures/casts/issue_982_disjoint.ts | 0 .../tests/fixtures/casts/issue_982_literal_overlap.ts | 0 .../tests/fixtures/casts/uint8array_is_as.ts | 0 .../casts/unknown_to_number_throws_and_catches.subm | 0 .../tests/fixtures/chain_generic_method_reference.ts | 0 .../tests/fixtures/chain_non_generic_optional_calls.ts | 0 .../fixtures/check_discipline/clean_destructure/lib.ts | 0 .../check_discipline/clean_destructured_param/lib.ts | 0 .../fixtures/check_discipline/clean_exported_arrow/lib.ts | 0 .../tests/fixtures/check_discipline/clean_for_of/lib.ts | 0 .../fixtures/check_discipline/clean_narrowed_root/lib.ts | 0 .../fixtures/check_discipline/clean_package_value/lib.ts | 0 .../fixtures/check_discipline/clean_primitives/lib.ts | 0 .../check_discipline/clean_response_mapping/lib.ts | 0 .../check_discipline/clean_sibling_of_checked/lib.ts | 0 .../check_discipline/clean_unchecked_payload/lib.ts | 0 .../fixtures/check_discipline/clean_unguarded/lib.ts | 0 .../fixtures/check_discipline/escape_argument/lib.ts | 0 .../fixtures/check_discipline/escape_array_literal/lib.ts | 0 .../fixtures/check_discipline/escape_callback/lib.ts | 0 .../fixtures/check_discipline/escape_captured/lib.ts | 0 .../check_discipline/escape_checked_ancestor/lib.ts | 0 .../tests/fixtures/check_discipline/escape_context/lib.ts | 0 .../tests/fixtures/check_discipline/escape_merged/lib.ts | 0 .../fixtures/check_discipline/escape_method_call/lib.ts | 0 .../fixtures/check_discipline/escape_mutation/lib.ts | 0 .../tests/fixtures/check_discipline/escape_operand/lib.ts | 0 .../fixtures/check_discipline/escape_returned/lib.ts | 0 .../tests/fixtures/check_discipline/escape_spread/lib.ts | 0 .../tests/fixtures/check_discipline/escape_stored/lib.ts | 0 .../tests/fixtures/check_discipline/escape_thrown/lib.ts | 0 .../fixtures/check_discipline/placement_closure/lib.ts | 0 .../check_discipline/placement_conditional_arrows/lib.ts | 0 .../placement_internal_module/internal.ts | 0 .../check_discipline/placement_internal_module/lib.ts | 0 .../fixtures/check_discipline/placement_members/lib.ts | 0 .../check_discipline/placement_module_level/lib.ts | 0 .../check_discipline/placement_private_helper/lib.ts | 0 .../check_discipline/placement_reexport/internal.ts | 0 .../fixtures/check_discipline/placement_reexport/lib.ts | 0 .../check_discipline/placement_unexported_arrow/lib.ts | 0 .../fixtures/check_discipline/repeated_iteration/lib.ts | 0 .../tests/fixtures/check_discipline/repeated_read/lib.ts | 0 .../fixtures/check_discipline/repeated_read_alias/lib.ts | 0 .../check_discipline/repeated_read_cast_arrow/lib.ts | 0 .../check_discipline/repeated_read_control/lib.ts | 0 .../check_discipline/repeated_read_early_exit/lib.ts | 0 .../check_discipline/repeated_read_exported_arrow/lib.ts | 0 .../fixtures/check_discipline/repeated_read_loop/lib.ts | 0 .../check_discipline/repeated_read_module_variable/lib.ts | 0 .../check_discipline/repeated_read_narrowed/lib.ts | 0 .../check_discipline/repeated_read_through_helper/lib.ts | 0 .../tests/fixtures/class_chain_at_limit.ts | 0 .../tests/fixtures/class_never_field_collection_key.ts | 0 .../tests/fixtures/class_to_string_field.ts | 0 .../fixtures/class_used_before_declaration_throws.ts | 0 .../tests/fixtures/classes/abstract_member.ts | 0 .../classes/accessor_across_package_boundary/app/main.ts | 0 .../classes/accessor_across_package_boundary/lib/lib.ts | 0 .../accessor_across_package_boundary/packages.manifest | 0 .../tests/fixtures/classes/accessor_basic.ts | 0 .../fixtures/classes/accessor_cross_package/app/main.ts | 0 .../fixtures/classes/accessor_cross_package/geo/lib.ts | 0 .../classes/accessor_cross_package/packages.manifest | 0 .../tests/fixtures/classes/accessor_different_types.ts | 0 .../tests/fixtures/classes/accessor_half_inherited.ts | 0 .../fixtures/classes/accessor_implements_readonly.ts | 0 .../classes/accessor_name_is_not_proof_of_an_accessor.ts | 0 .../tests/fixtures/classes/accessor_override.ts | 0 .../tests/fixtures/classes/accessor_readonly.ts | 0 .../fixtures/classes/accessor_redeclared_compatibly.ts | 0 .../tests/fixtures/classes/accessor_via_interface.ts | 0 .../tests/fixtures/classes/accessor_write_only.ts | 0 .../tests/fixtures/classes/bad_override.ts | 0 .../fixtures/classes/captured_class_binding_boxed.ts | 0 .../tests/fixtures/classes/cast_accessor_conformance.ts | 0 .../classes/cast_accessor_cross_package/app/main.ts | 0 .../classes/cast_accessor_cross_package/geo/lib.ts | 0 .../classes/cast_accessor_cross_package/packages.manifest | 0 .../tests/fixtures/classes/catch_generic_error_bare.ts | 0 .../tests/fixtures/classes/closure_captures_this.ts | 0 .../tests/fixtures/classes/closure_in_member_bodies.ts | 0 .../classes/compound_assign_cross_package/app/main.ts | 0 .../classes/compound_assign_cross_package/counters/lib.ts | 0 .../compound_assign_cross_package/packages.manifest | 0 .../classes/compound_assign_cross_package/tickers/lib.ts | 0 .../tests/fixtures/classes/compound_assign_field.ts | 0 .../fixtures/classes/compound_assign_generic_field.ts | 0 .../tests/fixtures/classes/construct_and_read_fields.ts | 0 .../classes/ctor_class_param_cross_package/app/main.ts | 0 .../classes/ctor_class_param_cross_package/lib/lib.ts | 0 .../ctor_class_param_cross_package/packages.manifest | 0 .../tests/fixtures/classes/ctor_default_and_rest.ts | 0 .../classes/ctor_default_rest_cross_package/app/main.ts | 0 .../classes/ctor_default_rest_cross_package/lib/lib.ts | 0 .../ctor_default_rest_cross_package/packages.manifest | 0 .../classes/dispatched_defaults_packages/app/main.ts | 0 .../classes/dispatched_defaults_packages/lib/lib.ts | 0 .../dispatched_defaults_packages/packages.manifest | 0 .../tests/fixtures/classes/dynamic_dispatch.ts | 0 .../fixtures/classes/equals_cross_package/app/main.ts | 0 .../fixtures/classes/equals_cross_package/labeled/lib.ts | 0 .../classes/equals_cross_package/packages.manifest | 0 .../fixtures/classes/equals_cross_package/points/lib.ts | 0 .../tests/fixtures/classes/equals_error.ts | 0 .../tests/fixtures/classes/equals_nullable_field.ts | 0 .../tests/fixtures/classes/equals_sibling_same_shape.ts | 0 .../tests/fixtures/classes/equals_structural_fields.ts | 0 .../tests/fixtures/classes/equals_subclass_vs_base.ts | 0 .../fixtures/classes/equals_vs_other_runtime_types.ts | 0 .../tests/fixtures/classes/error_catch_closure_capture.ts | 0 .../tests/fixtures/classes/error_field_mutation.ts | 0 .../tests/fixtures/classes/error_subclass_basic.ts | 0 .../classes/error_subclass_cross_package/app/main.ts | 0 .../classes/error_subclass_cross_package/errs/lib.ts | 0 .../error_subclass_cross_package/packages.manifest | 0 .../tests/fixtures/classes/error_subclass_throw_catch.ts | 0 .../tests/fixtures/classes/error_subclass_typed_catch.ts | 0 .../classes/error_subclass_typed_catch_finally.ts | 0 .../tests/fixtures/classes/error_union_null.ts | 0 .../fixtures/classes/expect_error_accessor_half_guards.ts | 0 .../expect_error_accessor_redeclared_incompatibly.ts | 0 .../classes/expect_error_accessor_type_mismatch.ts | 0 .../classes/expect_error_assign_missing_static.ts | 0 .../app/main.ts | 0 .../counters/lib.ts | 0 .../packages.manifest | 0 .../expect_error_assign_private_static/app/main.ts | 0 .../expect_error_assign_private_static/counters/lib.ts | 0 .../expect_error_assign_private_static/packages.manifest | 0 .../app/main.ts | 0 .../counters/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_assign_static_method.ts | 0 .../classes/expect_error_assign_static_readonly.ts | 0 .../classes/expect_error_assign_static_wrong_type.ts | 0 .../fixtures/classes/expect_error_assign_to_method.ts | 0 .../fixtures/classes/expect_error_bare_class_value.ts | 0 .../fixtures/classes/expect_error_catch_generic_args.ts | 0 .../fixtures/classes/expect_error_catch_non_error.ts | 0 .../classes/expect_error_catch_unrelated_class.ts | 0 .../classes/expect_error_compound_assign_readonly.ts | 0 .../classes/expect_error_ctor_arity_default_rest.ts | 0 .../classes/expect_error_deep_chain_shape_dump.ts | 0 .../classes/expect_error_field_redeclared_visibility.ts | 0 .../classes/expect_error_field_redeclared_wider.ts | 0 .../expect_error_field_used_before_initialization.ts | 0 .../classes/expect_error_generic_chain_shape_dump.ts | 0 .../classes/expect_error_getter_only_vs_settable.ts | 0 .../classes/expect_error_implements_aliased_interface.ts | 0 .../expect_error_implements_aliased_non_interface.ts | 0 .../classes/expect_error_implements_missing_member.ts | 0 .../classes/expect_error_implements_wrong_arity.ts | 0 .../classes/expect_error_implements_wrong_signature.ts | 0 .../fixtures/classes/expect_error_instance_on_class.ts | 0 .../fixtures/classes/expect_error_instanceof_interface.ts | 0 .../expect_error_instanceof_uint8array_unrelated.ts | 0 .../fixtures/classes/expect_error_instanceof_unrelated.ts | 0 .../classes/expect_error_member_closures_and_switches.ts | 0 .../classes/expect_error_member_missing_return.ts | 0 .../classes/expect_error_member_unreachable_code.ts | 0 .../classes/expect_error_method_switch_fallthrough.ts | 0 .../classes/expect_error_optional_vs_required_member.ts | 0 .../classes/expect_error_override_fewer_params.ts | 0 .../classes/expect_error_param_prop_outside_ctor.ts | 0 .../classes/expect_error_postfix_static_readonly.ts | 0 .../classes/expect_error_postfix_static_string.ts | 0 .../grand.ts | 0 .../expect_error_private_constructor_cross_module/lib.ts | 0 .../point.ts | 0 .../app/main.ts | 0 .../packages.manifest | 0 .../shapes/lib.ts | 0 .../fixtures/classes/expect_error_read_write_only.ts | 0 .../classes/expect_error_readonly_field_vs_settable.ts | 0 .../expect_error_redeclared_at_a_different_kind.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_static_accessor.ts | 0 .../fixtures/classes/expect_error_static_class_generic.ts | 0 .../fixtures/classes/expect_error_static_constructor.ts | 0 .../fixtures/classes/expect_error_static_field_no_init.ts | 0 .../expect_error_static_instance_name_collision.ts | 0 .../fixtures/classes/expect_error_static_on_instance.ts | 0 .../classes/expect_error_static_on_instance_help.ts | 0 .../classes/expect_error_static_optional_field.ts | 0 .../tests/fixtures/classes/expect_error_static_this.ts | 0 .../expect_error_static_via_namespace_import/app/main.ts | 0 .../expect_error_static_via_namespace_import/mathx/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_subclass_shape_dump.ts | 0 .../fixtures/classes/expect_error_to_string_signature.ts | 0 .../classes/expect_error_type_beats_mutability.ts | 0 .../fixtures/classes/expect_error_uninitialized_field.ts | 0 .../classes/expect_error_uninitialized_one_branch.ts | 0 .../tests/fixtures/classes/expect_error_unknown_static.ts | 0 .../fixtures/classes/extends_cross_module/app/main.ts | 0 .../classes/extends_cross_module/packages.manifest | 0 .../fixtures/classes/extends_cross_module/zoo/animal.ts | 0 .../fixtures/classes/extends_cross_module/zoo/lib.ts | 0 .../fixtures/classes/extends_cross_package/animals/lib.ts | 0 .../fixtures/classes/extends_cross_package/app/main.ts | 0 .../fixtures/classes/extends_cross_package/dogs/lib.ts | 0 .../classes/extends_cross_package/packages.manifest | 0 .../classes/extends_cross_package_private/animals/lib.ts | 0 .../classes/extends_cross_package_private/app/main.ts | 0 .../extends_cross_package_private/packages.manifest | 0 .../tests/fixtures/classes/extends_cycle.ts | 0 .../tests/fixtures/classes/extends_non_class.ts | 0 .../tests/fixtures/classes/field_init_inherited.ts | 0 .../tests/fixtures/classes/field_initializers.ts | 0 .../fixtures/classes/field_narrowing_guard_all_reads.ts | 0 .../classes/field_narrowing_guard_ancestor_view.ts | 0 .../classes/field_narrowing_guard_cast_interface.ts | 0 .../fixtures/classes/field_narrowing_guard_constructor.ts | 0 .../field_narrowing_guard_cross_package/app/main.ts | 0 .../field_narrowing_guard_cross_package/lib/lib.ts | 0 .../field_narrowing_guard_cross_package/packages.manifest | 0 .../tests/fixtures/classes/field_narrowing_guard_enums.ts | 0 .../classes/field_narrowing_guard_erased_method.ts | 0 .../classes/field_narrowing_guard_factory_constructor.ts | 0 .../fixtures/classes/field_narrowing_guard_generic_box.ts | 0 .../classes/field_narrowing_guard_generic_context.ts | 0 .../classes/field_narrowing_guard_generic_factory.ts | 0 .../classes/field_narrowing_guard_generic_payload.ts | 0 .../field_narrowing_guard_hidden_package/app/main.ts | 0 .../field_narrowing_guard_hidden_package/lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/field_narrowing_guard_host_info.ts | 0 .../classes/field_narrowing_guard_nullable_factory.ts | 0 .../classes/field_narrowing_guard_nullable_interface.ts | 0 .../classes/field_narrowing_guard_union_interface.ts | 0 .../classes/field_redeclared_cross_package/app/main.ts | 0 .../classes/field_redeclared_cross_package/lib/lib.ts | 0 .../field_redeclared_cross_package/packages.manifest | 0 .../fixtures/classes/field_redeclared_in_subclass.ts | 0 .../classes/field_redeclared_narrowing_write_throws.ts | 0 .../field_redeclared_private_cross_package/app/main.ts | 0 .../field_redeclared_private_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../classes/field_redeclared_without_initializer.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/implements_aliased_interface.ts | 0 .../fixtures/classes/implements_inherited_accessor.ts | 0 .../implements_inherited_cross_package/app/main.ts | 0 .../implements_inherited_cross_package/base/lib.ts | 0 .../implements_inherited_cross_package/packages.manifest | 0 .../classes/implements_inherited_empty_subclass.ts | 0 .../fixtures/classes/implements_inherited_generic_base.ts | 0 .../classes/implements_inherited_partial_override.ts | 0 .../classes/implements_inherited_subclass_extra_member.ts | 0 .../tests/fixtures/classes/implements_interface.ts | 0 .../classes/implements_via_later_declared_parent.ts | 0 .../tests/fixtures/classes/implicit_ctor.ts | 0 .../fixtures/classes/instanceof_cross_module/animals.ts | 0 .../tests/fixtures/classes/instanceof_cross_module/lib.ts | 0 .../fixtures/classes/instanceof_cross_package/app/main.ts | 0 .../classes/instanceof_cross_package/packages.manifest | 0 .../classes/instanceof_cross_package/rects/lib.ts | 0 .../classes/instanceof_cross_package/shapes/lib.ts | 0 .../tests/fixtures/classes/instanceof_error_chain.ts | 0 .../tests/fixtures/classes/instanceof_narrow.ts | 0 .../tests/fixtures/classes/instanceof_negative.ts | 0 .../fixtures/classes/instanceof_sibling_same_shape.ts | 0 .../tests/fixtures/classes/instanceof_uint8array.ts | 0 .../instanceof_uint8array_cross_package/app/main.ts | 0 .../instanceof_uint8array_cross_package/bytes/lib.ts | 0 .../instanceof_uint8array_cross_package/packages.manifest | 0 .../fixtures/classes/instanceof_uint8array_generic.ts | 0 .../fixtures/classes/instanceof_uint8array_host_built.ts | 0 .../fixtures/classes/instanceof_uint8array_narrow.ts | 0 .../tests/fixtures/classes/instanceof_unknown_lhs.ts | 0 .../tests/fixtures/classes/issue_927.ts | 0 .../tests/fixtures/classes/issue_927_argument_order.ts | 0 .../tests/fixtures/classes/issue_927_cycle.ts | 0 .../tests/fixtures/classes/issue_927_fixed_cycle.ts | 0 .../tests/fixtures/classes/issue_927_interface.ts | 0 .../tests/fixtures/classes/issue_927_union_cycle.ts | 0 .../fixtures/classes/issue_967_checked_return_abi.ts | 0 .../tests/fixtures/classes/issue_967_default_interface.ts | 0 .../tests/fixtures/classes/issue_967_required.ts | 0 .../fixtures/classes/issue_967_structural_defaults.ts | 0 .../tests/fixtures/classes/issue_967_wrong_parameter.ts | 0 .../fixtures/classes/issue_973_shorthand_boundary.ts | 0 .../tests/fixtures/classes/issue_987_inline_object.ts | 0 .../tests/fixtures/classes/issue_987_private.ts | 0 .../tests/fixtures/classes/issue_987_setter_only.ts | 0 .../tests/fixtures/classes/issue_987_weak_target.ts | 0 .../fixtures/classes/json_inherited_private/app/main.ts | 0 .../fixtures/classes/json_inherited_private/lib/lib.ts | 0 .../classes/json_inherited_private/packages.manifest | 0 .../tests/fixtures/classes/json_public_properties.ts | 0 .../tests/fixtures/classes/map_set_class_keys.ts | 0 .../tests/fixtures/classes/method_dispatch.ts | 0 .../classes/method_rewritten_cross_package/app/main.ts | 0 .../classes/method_rewritten_cross_package/lib/lib.ts | 0 .../method_rewritten_cross_package/packages.manifest | 0 .../fixtures/classes/method_rewritten_through_alias.ts | 0 .../classes/multi_catch_cross_package/app/main.ts | 0 .../classes/multi_catch_cross_package/errs/lib.ts | 0 .../classes/multi_catch_cross_package/packages.manifest | 0 .../classes/mutable_conversion_cross_package/app/main.ts | 0 .../classes/mutable_conversion_cross_package/base/lib.ts | 0 .../mutable_conversion_cross_package/packages.manifest | 0 .../fixtures/classes/object_literal_in_member_bodies.ts | 0 .../tests/fixtures/classes/overridden_defaults.ts | 0 .../tests/fixtures/classes/param_properties.ts | 0 .../fixtures/classes/permission_denied_error_builtin.ts | 0 .../tests/fixtures/classes/postfix_field_expression.ts | 0 .../classes/private_constructor_packages/app/main.ts | 0 .../private_constructor_packages/packages.manifest | 0 .../classes/private_constructor_packages/shapes/lib.ts | 0 .../tests/fixtures/classes/private_cross_module/animal.ts | 0 .../tests/fixtures/classes/private_cross_module/lib.ts | 0 .../tests/fixtures/classes/protected_member.ts | 0 .../tests/fixtures/classes/quota_exceeded_error.ts | 0 .../tests/fixtures/classes/range_error_builtin.ts | 0 .../tests/fixtures/classes/range_error_host_throws.ts | 0 .../tests/fixtures/classes/readonly_write_outside_ctor.ts | 0 .../classes/recursive_guard_same_name_packages/a/lib.ts | 0 .../recursive_guard_same_name_packages/app/main.ts | 0 .../classes/recursive_guard_same_name_packages/b/lib.ts | 0 .../recursive_guard_same_name_packages/packages.manifest | 0 .../tests/fixtures/classes/setter_assignment_as_value.ts | 0 .../fixtures/classes/static_and_instance_same_name.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../classes/static_classref_cross_package/app/main.ts | 0 .../classes/static_classref_cross_package/lib/lib.ts | 0 .../static_classref_cross_package/packages.manifest | 0 .../fixtures/classes/static_cross_package/app/main.ts | 0 .../fixtures/classes/static_cross_package/mathx/lib.ts | 0 .../classes/static_cross_package/packages.manifest | 0 .../tests/fixtures/classes/static_generic_method.ts | 0 .../tests/fixtures/classes/static_inheritance.ts | 0 .../fixtures/classes/static_instance_name_collision.ts | 0 .../fixtures/classes/static_members_do_not_redeclare.ts | 0 .../tests/fixtures/classes/static_method_as_value.ts | 0 .../tests/fixtures/classes/static_method_basic.ts | 0 .../tests/fixtures/classes/static_mutable_assign.ts | 0 .../classes/static_mutable_cross_package/app/main.ts | 0 .../classes/static_mutable_cross_package/counters/lib.ts | 0 .../static_mutable_cross_package/packages.manifest | 0 .../tests/fixtures/classes/static_mutable_field.ts | 0 .../fixtures/classes/static_mutable_inherited_write.ts | 0 .../tests/fixtures/classes/static_mutable_postfix.ts | 0 .../tests/fixtures/classes/static_mutable_private.ts | 0 .../tests/fixtures/classes/static_private.ts | 0 .../tests/fixtures/classes/static_readonly_field.ts | 0 .../classes/static_ref_types_cross_package/app/main.ts | 0 .../static_ref_types_cross_package/packages.manifest | 0 .../classes/static_ref_types_cross_package/strx/lib.ts | 0 .../tests/fixtures/classes/super_chain.ts | 0 .../tests/fixtures/classes/super_ctor_field_init.ts | 0 .../tests/fixtures/classes/super_method_override.ts | 0 .../tests/fixtures/classes/syntax_error_builtin.ts | 0 .../tests/fixtures/classes/this_in_field_initializer.ts | 0 .../tests/fixtures/classes/this_outside_method.ts | 0 .../transitive_dep_closure_cross_package/app/main.ts | 0 .../transitive_dep_closure_cross_package/lib1/lib.ts | 0 .../transitive_dep_closure_cross_package/lib2/lib.ts | 0 .../transitive_dep_closure_cross_package/mid/lib.ts | 0 .../packages.manifest | 0 .../app/main.ts | 0 .../lib1/lib.ts | 0 .../lib2/lib.ts | 0 .../mid/lib.ts | 0 .../packages.manifest | 0 .../tests/fixtures/classes/type_error_builtin.ts | 0 .../tests/fixtures/classes/type_error_host_thrown.ts | 0 .../classes/typed_catch_cross_package/app/main.ts | 0 .../classes/typed_catch_cross_package/errs/lib.ts | 0 .../classes/typed_catch_cross_package/packages.manifest | 0 .../tests/fixtures/classes/undefined_reference_error.ts | 0 .../tests/fixtures/classes/universal_to_json.ts | 0 .../tests/fixtures/classes/universal_to_string.ts | 0 .../unused_static_thirdpkg_cross_package/app/main.ts | 0 .../unused_static_thirdpkg_cross_package/base/lib.ts | 0 .../unused_static_thirdpkg_cross_package/consumer/lib.ts | 0 .../unused_static_thirdpkg_cross_package/mid/lib.ts | 0 .../packages.manifest | 0 .../unused_statics_not_imported_cross_package/app/main.ts | 0 .../unused_statics_not_imported_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../tests/fixtures/closure_captures_class_union.ts | 0 .../fixtures/closure_coercion_cross_package/app/main.ts | 0 .../fixtures/closure_coercion_cross_package/lib/lib.ts | 0 .../closure_coercion_cross_package/packages.manifest | 0 .../tests/fixtures/closure_counter.subm | 0 .../tests/fixtures/closure_nullable_return.ts | 0 .../tests/fixtures/closure_reads_later_module_variable.ts | 0 .../tests/fixtures/closure_sig_accessor_dispatch.ts | 0 .../tests/fixtures/closure_sig_after_substitution.ts | 0 .../tests/fixtures/closure_sig_from_class_members.ts | 0 .../tests/fixtures/closure_sig_from_local_slot.ts | 0 .../fixtures/closure_sig_from_uncalled_signatures.ts | 0 .../tests/fixtures/closure_sig_shape_dispatch.ts | 0 .../tests/fixtures/closure_that_only_throws_is_never.ts | 0 .../tests/fixtures/closure_variable_passed_to_hof.subm | 0 .../fixtures/closures/callbacks_declare_fewer_params.ts | 0 .../tests/fixtures/closures/function_arity_edges.ts | 0 .../tests/fixtures/closures/function_this.ts | 0 .../tests/fixtures/closures/iife.subm | 0 .../tests/fixtures/closures/named_function_expression.ts | 0 .../tests/fixtures/closures/nested_function_contexts.ts | 0 .../fixtures/closures/nested_function_declarations.ts | 0 .../tests/fixtures/code/linear_diff.ts | 0 .../tests/fixtures/code/workspace.ts | 0 .../tests/fixtures/collection_iterators_live.ts | 0 .../tests/fixtures/collection_keys_same_value_zero.ts | 0 .../fixtures/collection_regressions/array_from_mapping.ts | 0 .../collection_regressions/array_from_nullable.ts | 0 .../fixtures/collection_regressions/array_postfix_only.ts | 0 .../expect_error_optional_tuple_index.ts | 0 .../collection_regressions/expect_error_spread_arity.ts | 0 .../collection_regressions/expect_error_spread_array.ts | 0 .../collection_regressions/expect_error_spread_slot.ts | 0 .../fixtures/collection_regressions/optional_index.ts | 0 .../collection_regressions/optional_index_bounds.ts | 0 .../tests/fixtures/collection_regressions/spread_order.ts | 0 .../tests/fixtures/collection_regressions/tuple_boxing.ts | 0 .../tests/fixtures/collection_regressions/tuple_spread.ts | 0 .../fixtures/collection_regressions/uint8_postfix.ts | 0 .../fixtures/collection_regressions/uint8_postfix_only.ts | 0 .../tests/fixtures/collection_to_string_tag.ts | 0 .../fixtures/comparable_methods_and_self_references.ts | 0 .../fixtures/compound_assign/compound_basic_number.subm | 0 .../tests/fixtures/compound_assign/compound_bigint.subm | 0 .../fixtures/compound_assign/compound_const_error.subm | 0 .../tests/fixtures/compound_assign/compound_field.subm | 0 .../tests/fixtures/compound_assign/compound_for_loop.subm | 0 .../tests/fixtures/compound_assign/compound_index.subm | 0 .../fixtures/compound_assign/compound_narrowing.subm | 0 .../fixtures/compound_assign/compound_pow_precedence.subm | 0 .../tests/fixtures/compound_assign/compound_string.subm | 0 .../compound_assign/compound_type_error_mixed.subm | 0 .../compound_assign/compound_type_error_string_sub.subm | 0 .../fixtures/compound_assign/receiver_evaluated_once.ts | 0 .../fixtures/compound_assignment_through_never_getter.ts | 0 .../fixtures/compound_write_widens_literal_target.ts | 0 .../fixtures/conditional_object_literal_normalization.ts | 0 .../tests/fixtures/conformance_array.subm | 0 .../tests/fixtures/conformance_bigint.subm | 0 .../tests/fixtures/conformance_boolean.subm | 0 .../tests/fixtures/conformance_json.subm | 0 .../tests/fixtures/conformance_map_set.subm | 0 .../tests/fixtures/conformance_math.subm | 0 .../tests/fixtures/conformance_number.subm | 0 .../tests/fixtures/conformance_object.subm | 0 .../tests/fixtures/conformance_regexp.subm | 0 .../tests/fixtures/conformance_string.subm | 0 .../tests/fixtures/conformance_temporal.subm | 0 .../tests/fixtures/conformance_uint8array.subm | 0 .../tests/fixtures/console_log_null.ts | 0 .../tests/fixtures/console_log_variadic.subm | 0 .../fixtures/const_keeps_literals_through_operators.ts | 0 .../fixtures/const_literal_survives_through_ternaries.ts | 0 .../fixtures/const_literal_survives_where_immutable.ts | 0 .../tests/fixtures/const_literal_widens_where_mutable.ts | 0 .../tests/fixtures/constant_expression_literal_types.ts | 0 .../tests/fixtures/constant_key_reads_as_field.ts | 0 .../fixtures/contextual-keywords/all_five_as_names.ts | 0 .../contextual-keywords/asi_newline_before_as_splits.ts | 0 .../contextual-keywords/for_of_binding_named_of.ts | 0 .../fixtures/contextual-keywords/from_binding_template.ts | 0 .../contextual-keywords/keyword_positions_still_work.ts | 0 .../contextual-keywords/type_only_import_inline.ts | 0 .../contextual-keywords/type_only_import_statement.ts | 0 .../tests/fixtures/conversion_field_rest_and_this.ts | 0 .../tests/fixtures/crypto/hmac_sha256.subm | 0 .../tests/fixtures/crypto/random_bytes.subm | 0 .../tests/fixtures/crypto/sha256.subm | 0 .../tests/fixtures/crypto/sha512.subm | 0 .../tests/fixtures/crypto/timing_safe_equal.subm | 0 .../tests/fixtures/cyclic_graph_host_walk.ts | 0 .../tests/fixtures/date_lowercase_variable_works.subm | 0 .../tests/fixtures/decode_uri_lone_surrogates.ts | 0 .../tests/fixtures/default_param_arrow.ts | 0 .../tests/fixtures/default_param_basic.subm | 0 .../tests/fixtures/default_param_before_required.ts | 0 .../tests/fixtures/default_param_boxed_slot.ts | 0 .../tests/fixtures/default_param_enum_variant.subm | 0 .../tests/fixtures/default_param_expression.ts | 0 .../tests/fixtures/default_param_global_const.ts | 0 .../tests/fixtures/default_param_method.subm | 0 .../tests/fixtures/destructuring/array_hole.subm | 0 .../fixtures/destructuring/array_literal_as_tuple.subm | 0 .../tests/fixtures/destructuring/array_positional.subm | 0 .../tests/fixtures/destructuring/array_rest.subm | 0 .../fixtures/destructuring/arrow_param_expr_body.subm | 0 .../tests/fixtures/destructuring/class_member_params.ts | 0 .../fixtures/destructuring/defaults_pad_literal_tuple.ts | 0 .../expect_error_annotated_undefined_component_default.ts | 0 .../destructuring/expect_error_array_literal_arity.subm | 0 .../destructuring/expect_error_for_initializer_capture.ts | 0 .../destructuring/expect_error_for_initializer_parse.ts | 0 .../fixtures/destructuring/expect_error_for_of_arity.subm | 0 .../destructuring/expect_error_for_of_non_tuple.subm | 0 .../tests/fixtures/destructuring/expect_error_nested.subm | 0 .../expect_error_pattern_longer_than_literal.ts | 0 .../destructuring/expect_error_rest_not_last.subm | 0 .../tests/fixtures/destructuring/for_initializer.ts | 0 .../tests/fixtures/destructuring/for_of_map.subm | 0 .../tests/fixtures/destructuring/for_of_tuple.subm | 0 .../tests/fixtures/destructuring/function_param.subm | 0 .../fixtures/destructuring/let_pattern_mutation.subm | 0 .../tests/fixtures/destructuring/nested_in_block.subm | 0 .../tests/fixtures/destructuring/object_rename.subm | 0 .../tests/fixtures/destructuring/object_rest.subm | 0 .../tests/fixtures/destructuring/object_shorthand.subm | 0 .../tests/fixtures/destructuring/parameter_defaults.ts | 0 .../tests/fixtures/destructuring/pattern_defaults.ts | 0 .../tests/fixtures/destructuring/single_eval_rhs.subm | 0 .../tests/fixtures/destructuring_initializer_flow.ts | 0 .../tests/fixtures/diagnostic_counts/accessor.ts | 0 .../tests/fixtures/diagnostic_counts/array.ts | 0 .../tests/fixtures/diagnostic_counts/getter.ts | 0 .../tests/fixtures/diagnostic_counts/interface.ts | 0 .../diagnostic_counts/package_warnings/dep/lib.ts | 0 .../diagnostic_counts/package_warnings/packages.manifest | 0 .../diagnostic_counts/package_warnings/root/main.ts | 0 .../diagnostic_counts/package_warnings_error/dep/lib.ts | 0 .../package_warnings_error/packages.manifest | 0 .../diagnostic_counts/package_warnings_error/root/main.ts | 0 .../tests/fixtures/diagnostic_counts/spread_array.ts | 0 .../tests/fixtures/diagnostic_counts/spread_tuple.ts | 0 .../tests/fixtures/diagnostic_counts/tuple.ts | 0 .../tests/fixtures/diagnostic_counts/unhinted_array.ts | 0 .../fixtures/discriminated_union_object_literal.subm | 0 .../tests/fixtures/doc_callable_members.ts | 0 .../fixtures/doc_comments/capability_context_fields.ts | 0 ...xpect_error_payload_key_missing_from_capability_doc.ts | 0 ...t_warning_capability_binding_missing_from_payload.subm | 0 .../expect_warning_missing_capability_tag.subm | 0 .../doc_comments/expect_warning_missing_param_doc.subm | 0 .../tests/fixtures/duplicate_parameter_names.ts | 0 .../tests/fixtures/embedding_basic.ts | 0 .../tests/fixtures/embedding_bounds.ts | 0 .../tests/fixtures/embedding_budget_per_run.ts | 0 .../tests/fixtures/embedding_denied.ts | 0 .../tests/fixtures/embedding_error_taxonomy.ts | 0 .../tests/fixtures/embedding_input_too_long.ts | 0 .../tests/fixtures/embedding_models.ts | 0 .../tests/fixtures/embedding_models_filtered.ts | 0 .../tests/fixtures/embedding_no_provider.ts | 0 .../tests/fixtures/embedding_purpose_invalid.ts | 0 .../tests/fixtures/embedding_unknown_alias.ts | 0 .../tests/fixtures/emitter_fallible_healthy.ts | 0 .../tests/fixtures/emitter_state_healthy.ts | 0 .../tests/fixtures/empty_array_cast.ts | 0 .../tests/fixtures/empty_array_cast_non_array.ts | 0 .../tests/fixtures/empty_array_never.ts | 0 .../fixtures/enum_member_cases_match_their_own_enum.ts | 0 .../tests/fixtures/enum_member_comparison_narrows.ts | 0 .../tests/fixtures/enum_member_types.ts | 0 .../tests/fixtures/enum_negative_zero_initializer.ts | 0 .../fixtures/enums/enum_decl_numeric_typechecks.subm | 0 .../tests/fixtures/enums/enum_decl_string_typechecks.subm | 0 .../tests/fixtures/enums/enum_runtime_numeric.subm | 0 .../tests/fixtures/enums/enum_runtime_string.subm | 0 .../tests/fixtures/enums/expect_error_enum_as_value.subm | 0 .../fixtures/enums/expect_error_enum_mixed_kinds.subm | 0 .../enums/expect_error_enum_string_missing_value.subm | 0 .../fixtures/enums/expect_error_enum_unknown_variant.subm | 0 .../tests/fixtures/equality_comparable_operands.ts | 0 .../tests/fixtures/equality_literal_operands.ts | 0 .../tests/fixtures/error_constructor_default_message.ts | 0 .../tests/fixtures/error_is_error.subm | 0 .../tests/fixtures/error_is_error_nominal.ts | 0 .../tests/fixtures/error_subclass_object_keys.ts | 0 .../tests/fixtures/error_subclass_to_string.ts | 0 .../tests/fixtures/errors/call_sig_duplicate.subm | 0 .../tests/fixtures/errors/call_sig_not_callable.subm | 0 .../tests/fixtures/errors/default_param_in_fn_type.subm | 0 .../fixtures/errors/default_param_type_mismatch.subm | 0 .../errors/expect_error_reserved_keyword_binding.subm | 0 .../tests/fixtures/errors/issue_918_partial_catalog.ts | 0 .../tests/fixtures/errors/new_no_constructor.subm | 0 .../tests/fixtures/errors/new_no_parens.subm | 0 .../tests/fixtures/errors/postfix_inc_chain.subm | 0 .../tests/fixtures/errors/postfix_inc_const.subm | 0 .../tests/fixtures/errors/postfix_inc_non_numeric.subm | 0 .../fixtures/exceptions/break_outside_finally_scope.subm | 0 .../tests/fixtures/exceptions/catch_binding_reassign.ts | 0 .../tests/fixtures/exceptions/catch_bindingless.ts | 0 .../fixtures/exceptions/catch_runs_only_when_thrown.subm | 0 .../tests/fixtures/exceptions/catch_unknown.ts | 0 .../fixtures/exceptions/catch_untyped_binds_error.ts | 0 .../continue_in_try_finally_advances_for_loop.subm | 0 .../exceptions/continue_in_try_finally_for_of.subm | 0 .../exceptions/continue_in_try_finally_ordering.subm | 0 .../tests/fixtures/exceptions/deep_finally_transfers.ts | 0 .../tests/fixtures/exceptions/error_default_name.subm | 0 .../fixtures/exceptions/expect_error_bare_throw.subm | 0 .../tests/fixtures/exceptions/expect_error_bare_try.subm | 0 .../exceptions/expect_error_bindingless_catch_order.ts | 0 .../fixtures/exceptions/expect_error_catch_any_binding.ts | 0 .../expect_error_catch_binding_reassign_non_error.ts | 0 .../exceptions/expect_error_catch_non_error_type.subm | 0 .../exceptions/expect_error_catch_unknown_duplicate.ts | 0 .../exceptions/expect_error_catch_unknown_order.ts | 0 .../expect_error_multi_catch_after_catch_all.ts | 0 .../expect_error_multi_catch_duplicate_class.ts | 0 .../expect_error_multi_catch_general_before_specific.ts | 0 .../fixtures/exceptions/expect_error_throw_non_error.subm | 0 .../tests/fixtures/exceptions/finally_caught_path.subm | 0 .../finally_no_return_preserves_catch_rethrow.subm | 0 .../tests/fixtures/exceptions/finally_normal_path.subm | 0 .../exceptions/finally_preserves_pending_completion.ts | 0 .../finally_return_suppresses_catch_rethrow.subm | 0 .../tests/fixtures/exceptions/finally_runs_on_break.subm | 0 .../fixtures/exceptions/finally_runs_on_continue.subm | 0 .../tests/fixtures/exceptions/finally_runs_on_return.subm | 0 .../exceptions/finally_runs_on_return_in_catch.subm | 0 .../fixtures/exceptions/finally_transfer_runs_once.ts | 0 .../fixtures/exceptions/finally_with_own_return_wins.subm | 0 .../exceptions/multi_catch_conditional_narrowing.ts | 0 .../exceptions/multi_catch_fallthrough_general.ts | 0 .../fixtures/exceptions/multi_catch_finally_every_arm.ts | 0 .../tests/fixtures/exceptions/multi_catch_first_match.ts | 0 .../exceptions/multi_catch_return_in_arm_runs_finally.ts | 0 .../fixtures/exceptions/multi_catch_subclass_dispatch.ts | 0 .../exceptions/multi_catch_throw_in_arm_runs_finally.ts | 0 .../fixtures/exceptions/multi_catch_unmatched_rethrows.ts | 0 .../fixtures/exceptions/nested_finally_on_return.subm | 0 .../tests/fixtures/exceptions/nested_try.subm | 0 .../fixtures/exceptions/nested_try_finally_break.subm | 0 .../exceptions/return_in_finally_continues_outward.ts | 0 .../tests/fixtures/exceptions/throw_caught.subm | 0 .../exceptions/throw_in_function_caught_outside.subm | 0 .../expect_error_accessor_skipped_by_duplicate.ts | 0 .../fixtures/expect_error_annotated_callback_conflict.ts | 0 .../expect_error_annotated_destructuring_default.ts | 0 .../fixtures/expect_error_annotated_for_of_default.ts | 0 .../expect_error_array_from_array_like_element_type.ts | 0 ...expect_error_array_from_array_like_without_callback.ts | 0 .../expect_error_array_from_interface_array_like.ts | 0 .../expect_error_array_from_keyed_array_like.subm | 0 .../expect_error_array_keeps_regular_literal_type.ts | 0 .../fixtures/expect_error_array_type_after_line_break.ts | 0 .../fixtures/expect_error_arrow_body_and_signature.ts | 0 .../expect_error_assignment_expression_to_const.ts | 0 .../fixtures/expect_error_assignment_reported_once.ts | 0 .../fixtures/expect_error_bigint_literal_type_mismatch.ts | 0 .../expect_error_boolean_literal_type_mismatch.ts | 0 .../fixtures/expect_error_braceless_declaration_body.ts | 0 .../tests/fixtures/expect_error_braceless_declarations.ts | 0 .../fixtures/expect_error_break_in_nested_function.ts | 0 .../tests/fixtures/expect_error_callback_param_type.ts | 0 .../fixtures/expect_error_callback_return_mismatch.ts | 0 .../fixtures/expect_error_callback_too_many_params.ts | 0 .../fixtures/expect_error_callback_untyped_extra_param.ts | 0 .../expect_error_cast_union_without_member_overlap.ts | 0 .../tests/fixtures/expect_error_class_chain_limit.ts | 0 .../tests/fixtures/expect_error_class_in_function.ts | 0 .../expect_error_comparable_function_properties.ts | 0 .../tests/fixtures/expect_error_comparison_never_true.ts | 0 .../expect_error_compound_write_reads_base_type.ts | 0 .../expect_error_condition_write_after_narrowing.ts | 0 ...ct_error_conditional_assignment_keeps_declared_type.ts | 0 .../expect_error_const_literal_operators_mismatch.ts | 0 .../fixtures/expect_error_const_literal_union_mismatch.ts | 0 .../expect_error_constant_key_write_ends_field_guard.ts | 0 .../tests/fixtures/expect_error_date_constructor.subm | 0 .../tests/fixtures/expect_error_date_now.subm | 0 .../tests/fixtures/expect_error_date_type.subm | 0 ...xpect_error_default_parameter_before_required_arity.ts | 0 .../fixtures/expect_error_default_parameter_iife_tdz.ts | 0 .../expect_error_default_parameter_invalid_write.ts | 0 .../expect_error_defaulted_before_required_signature.ts | 0 .../tests/fixtures/expect_error_delete_unsupported.ts | 0 .../fixtures/expect_error_destructuring_flow_reset.ts | 0 .../expect_error_destructuring_source_flow_type.ts | 0 ..._error_discriminant_default_keeps_comparable_member.ts | 0 .../fixtures/expect_error_do_while_condition_write.ts | 0 .../fixtures/expect_error_duplicate_type_parameter.ts | 0 .../tests/fixtures/expect_error_empty_array_evolving.ts | 0 .../fixtures/expect_error_enum_member_type_mismatch.ts | 0 .../fixtures/expect_error_enum_switch_on_bare_literals.ts | 0 .../tests/fixtures/expect_error_equality_no_overlap.ts | 0 .../tests/fixtures/expect_error_error_new_method.ts | 0 .../expect_error_exhaustive_switch_leaves_never.ts | 0 .../fixtures/expect_error_exponentiation_asserted.ts | 0 .../tests/fixtures/expect_error_exponentiation_not.ts | 0 .../tests/fixtures/expect_error_exponentiation_plus.ts | 0 .../tests/fixtures/expect_error_exponentiation_typeof.ts | 0 .../tests/fixtures/expect_error_exponentiation_unary.ts | 0 .../tests/fixtures/expect_error_field_does_not_exist.subm | 0 .../fixtures/expect_error_generic_arg_contravariant.ts | 0 .../tests/fixtures/expect_error_generic_arg_supertype.ts | 0 .../tests/fixtures/expect_error_generic_argument_order.ts | 0 .../expect_error_generic_method_argument_order.ts | 0 .../expect_error_generic_type_argument_variance.ts | 0 .../fixtures/expect_error_generic_type_size_limit.ts | 0 .../tests/fixtures/expect_error_getter_needs_return.ts | 0 .../fixtures/expect_error_getter_without_return_type.ts | 0 .../tests/fixtures/expect_error_if_empty_body.ts | 0 .../expect_error_inferred_closure_return_is_widest.ts | 0 ...or_inferred_closure_returns_without_a_covering_type.ts | 0 .../expect_error_inferred_literal_unknown_field.ts | 0 .../fixtures/expect_error_inferred_literal_weak_type.ts | 0 .../fixtures/expect_error_inferred_type_depth_limit.ts | 0 .../expect_error_initializer_captured_mutation.ts | 0 .../tests/fixtures/expect_error_initializer_null.ts | 0 .../tests/fixtures/expect_error_initializer_readonly.ts | 0 .../fixtures/expect_error_interface_to_string_property.ts | 0 .../expect_error_interface_to_string_signature.ts | 0 ...er_module_annotation_error_beside_initializer_error.ts | 0 .../fixtures/expect_error_later_module_const_assigned.ts | 0 .../expect_error_later_module_namespace_read_directly.ts | 0 ..._later_module_variable_annotation_names_later_value.ts | 0 .../expect_error_later_module_variable_inferred_type.ts | 0 .../expect_error_later_module_variable_read_directly.ts | 0 .../tests/fixtures/expect_error_leading_zero_decimal.ts | 0 .../tests/fixtures/expect_error_legacy_octal_literal.ts | 0 .../expect_error_let_keeps_regular_literal_type.ts | 0 .../expect_error_literal_type_number_mismatch.subm | 0 .../expect_error_literal_type_string_mismatch.subm | 0 .../expect_error_lone_surrogate_literal_mismatch.subm | 0 .../tests/fixtures/expect_error_loop_condition_write.ts | 0 .../fixtures/expect_error_loose_nullish_both_sides.ts | 0 .../expect_error_loose_nullish_constant_results.ts | 0 .../expect_error_loose_nullish_effectful_operand.ts | 0 .../expect_error_loose_nullish_effects_and_lines.ts | 0 .../tests/fixtures/expect_error_loose_nullish_equality.ts | 0 .../fixtures/expect_error_loose_nullish_parenthesized.ts | 0 .../tests/fixtures/expect_error_loose_nullish_void.ts | 0 .../tests/fixtures/expect_error_lt_on_boolean.subm | 0 .../fixtures/expect_error_map_for_each_param_types.ts | 0 .../fixtures/expect_error_name_after_decimal_point.ts | 0 .../tests/fixtures/expect_error_nan_comparison.ts | 0 .../fixtures/expect_error_nested_function_duplicate.ts | 0 .../fixtures/expect_error_nested_function_generic.ts | 0 .../expect_error_nested_function_missing_return.ts | 0 .../expect_error_nested_function_outer_narrowing.ts | 0 .../expect_error_nested_function_reads_local_below.ts | 0 .../fixtures/expect_error_nested_function_reassigned.ts | 0 .../expect_error_nested_function_shadows_param.ts | 0 .../tests/fixtures/expect_error_nested_function_this.ts | 0 .../expect_error_nested_function_used_before_capture.ts | 0 ...t_error_nested_function_used_before_sibling_capture.ts | 0 ...sted_function_used_before_sibling_reads_local_below.ts | 0 .../expect_error_nested_function_used_through_alias.ts | 0 .../expect_error_nested_function_write_before_capture.ts | 0 .../expect_error_never_operand_needs_numeric_partner.ts | 0 .../tests/fixtures/expect_error_nullish_mixed_logical.ts | 0 .../fixtures/expect_error_number_plus_string_help.ts | 0 .../tests/fixtures/expect_error_numeric_separator.ts | 0 .../expect_error_object_literal_dictionary_union.ts | 0 .../fixtures/expect_error_object_rest_const_assign.ts | 0 .../expect_error_object_type_construct_signature.ts | 0 .../tests/fixtures/expect_error_optional_chain_limit.ts | 0 .../fixtures/expect_error_optional_chain_missing_key.ts | 0 .../fixtures/expect_error_optional_chain_on_namespace.ts | 0 .../tests/fixtures/expect_error_optional_chain_write.ts | 0 .../expect_error_optional_method_body_direct_call.ts | 0 .../expect_error_optional_method_body_receiver_chain.ts | 0 .../expect_error_optional_method_super_direct_call.ts | 0 .../expect_error_optional_null_field_into_optional.ts | 0 .../fixtures/expect_error_optional_parameter_default.ts | 0 .../expect_error_parameter_modifier_line_break.ts | 0 .../expect_error_parameterless_index_signature.ts | 0 ...expect_error_parenthesized_non_null_keeps_narrowing.ts | 0 ...ect_error_readonly_array_for_mutable_type_parameter.ts | 0 .../tests/fixtures/expect_error_readonly_cast_write.ts | 0 .../tests/fixtures/expect_error_readonly_constructor.ts | 0 .../expect_error_readonly_line_break_class_member.ts | 0 .../expect_error_readonly_line_break_type_member.ts | 0 .../tests/fixtures/expect_error_readonly_method.ts | 0 .../tests/fixtures/expect_error_regex_backreference.subm | 0 .../tests/fixtures/expect_error_regex_duplicate_flag.subm | 0 .../tests/fixtures/expect_error_regex_invalid_flag.subm | 0 .../fixtures/expect_error_regex_invalid_pattern.subm | 0 .../tests/fixtures/expect_error_regex_lookahead.subm | 0 .../tests/fixtures/expect_error_regex_lookbehind.subm | 0 .../tests/fixtures/expect_error_regex_named_backref.subm | 0 .../fixtures/expect_error_regex_negative_lookahead.subm | 0 .../fixtures/expect_error_regex_negative_lookbehind.subm | 0 .../tests/fixtures/expect_error_regex_unterminated.subm | 0 .../expect_error_required_parameter_after_optional.ts | 0 .../tests/fixtures/expect_error_rest_arity_too_few.subm | 0 .../expect_error_rest_callback_for_fixed_arity.ts | 0 .../tests/fixtures/expect_error_rest_no_annotation.subm | 0 .../tests/fixtures/expect_error_rest_non_array.subm | 0 .../tests/fixtures/expect_error_rest_not_last.subm | 0 .../tests/fixtures/expect_error_rest_with_default.subm | 0 .../tests/fixtures/expect_error_runtime_check_limit.ts | 0 .../fixtures/expect_error_runtime_check_locals_limit.ts | 0 .../tests/fixtures/expect_error_spread_fallback_limit.ts | 0 .../expect_error_spread_field_mismatches_interface.ts | 0 .../tests/fixtures/expect_error_spread_null.ts | 0 .../expect_error_spread_of_conditional_widens_field.ts | 0 ...pect_error_spread_optional_field_keeps_earlier_type.ts | 0 .../expect_error_spread_optional_into_required.ts | 0 .../fixtures/expect_error_spread_overwrites_union_tag.ts | 0 .../fixtures/expect_error_spread_union_may_be_empty.ts | 0 .../fixtures/expect_error_strict_mode_reserved_binding.ts | 0 .../tests/fixtures/expect_error_string_at_unnarrowed.ts | 0 .../expect_error_string_or_array_union_method_argument.ts | 0 .../fixtures/expect_error_string_plus_number_help.ts | 0 .../fixtures/expect_error_string_unknown_method.subm | 0 .../tests/fixtures/expect_error_super_conditional.ts | 0 .../fixtures/expect_error_super_in_function_expression.ts | 0 .../fixtures/expect_error_super_in_nested_function.ts | 0 .../tests/fixtures/expect_error_super_misplaced.ts | 0 .../fixtures/expect_error_super_reads_before_call.ts | 0 ...expect_error_switch_case_null_absent_optional_field.ts | 0 ...rror_switch_clause_local_shadows_before_declaration.ts | 0 ...expect_error_switch_clause_reads_other_clause_local.ts | 0 .../expect_error_switch_clause_redeclares_const.ts | 0 .../expect_error_switch_clause_redeclares_function.ts | 0 ..._switch_default_reads_before_later_case_declaration.ts | 0 ...xpect_error_switch_function_uses_other_clause_local.ts | 0 ...xpect_error_switch_later_clause_reads_shadowed_name.ts | 0 ...pect_error_switch_later_clause_writes_shadowed_name.ts | 0 ...t_error_switch_namespace_declared_in_another_clause.ts | 0 .../tests/fixtures/expect_error_syntax_nesting_limit.ts | 0 .../tests/fixtures/expect_error_template_nesting_limit.ts | 0 .../expect_error_temporal_duration_positional_ctor.ts | 0 .../expect_error_temporal_duration_weak_type_number.ts | 0 .../expect_error_this_in_unbound_function_expression.ts | 0 .../fixtures/expect_error_tostring_wrong_signature.subm | 0 .../tests/fixtures/expect_error_tostring_wrong_type.subm | 0 .../tests/fixtures/expect_error_tuple_arity_mismatch.subm | 0 .../tests/fixtures/expect_error_tuple_element_type.subm | 0 .../tests/fixtures/expect_error_tuple_empty_rejected.subm | 0 .../fixtures/expect_error_tuple_index_non_literal.subm | 0 .../tests/fixtures/expect_error_tuple_index_oob.subm | 0 .../tests/fixtures/expect_error_tuple_mutators.ts | 0 .../fixtures/expect_error_tuple_optional_rest_elements.ts | 0 .../tests/fixtures/expect_error_tuple_push.subm | 0 .../tests/fixtures/expect_error_tuple_sort.subm | 0 .../fixtures/expect_error_type_args_after_line_break.ts | 0 .../expect_error_type_declaration_named_like_builtin.ts | 0 .../tests/fixtures/expect_error_type_mismatch.subm | 0 .../tests/fixtures/expect_error_type_nesting_limit.ts | 0 ...ct_error_type_predicate_not_assignable_to_parameter.ts | 0 .../tests/fixtures/expect_error_type_size_limit.ts | 0 .../tests/fixtures/expect_error_typeof_invalid_tag.subm | 0 .../tests/fixtures/expect_error_typeof_of_a_type_name.ts | 0 .../tests/fixtures/expect_error_typeof_unknown_value.ts | 0 .../tests/fixtures/expect_error_unary_minus_string.ts | 0 .../fixtures/expect_error_unary_plus_nullable_string.ts | 0 .../expect_error_unclosed_interface_before_declaration.ts | 0 .../expect_error_unclosed_interface_before_export.ts | 0 ...pect_error_unclosed_type_literal_before_declaration.ts | 0 .../expect_error_undefined_local_const_pattern_write.ts | 0 ...ect_error_undefined_parameter_pattern_literal_write.ts | 0 ..._error_undefined_parameter_property_literal_default.ts | 0 .../expect_error_undefined_tuple_spread_required.ts | 0 .../expect_error_undefined_tuple_spread_required_union.ts | 0 .../expect_error_union_literal_assignment_only.ts | 0 .../fixtures/expect_error_union_literal_unknown_field.ts | 0 .../expect_error_union_literal_unknown_field_tags.ts | 0 .../fixtures/expect_error_visibility_after_readonly.ts | 0 .../fixtures/expect_error_void_compared_with_value.ts | 0 .../tests/fixtures/expect_error_void_condition.ts | 0 .../expect_error_void_conditional_into_value_slot.ts | 0 .../expect_error_void_parameter_default_keeps_void.ts | 0 .../fixtures/expect_error_weak_type_no_common_field.ts | 0 ...expect_warning_nullish_non_null_left_keeps_its_type.ts | 0 .../tests/fixtures/exponentiation_grouping.ts | 0 .../tests/fixtures/field_assignment_flow.ts | 0 .../tests/fixtures/for_of_string_or_array.ts | 0 .../tests/fixtures/fs/absence_probing.ts | 0 .../tests/fixtures/fs/append_text.subm | 0 .../tests/fixtures/fs/bytes_iteration.subm | 0 .../tests/fixtures/fs/bytes_write_read.subm | 0 .../tests/fixtures/fs/copy_creates_destination_parents.ts | 0 .../tests/fixtures/fs/cwd.ts | 0 .../tests/fixtures/fs/exists_size.subm | 0 .../tests/fixtures/fs/info_basic.subm | 0 .../tests/fixtures/fs/linear_remove_move.ts | 0 .../tests/fixtures/fs/lines_break.subm | 0 .../tests/fixtures/fs/lines_iteration.subm | 0 .../tests/fixtures/fs/list_deep.ts | 0 .../tests/fixtures/fs/list_entry_shape.ts | 0 .../tests/fixtures/fs/list_flat.subm | 0 .../tests/fixtures/fs/list_recursive.subm | 0 .../tests/fixtures/fs/many_handles_recovered.subm | 0 .../tests/fixtures/fs/max_read_size.subm | 0 .../tests/fixtures/fs/mkdir_nested.subm | 0 .../tests/fixtures/fs/move_copy_remove.subm | 0 .../tests/fixtures/fs/peek_basic.subm | 0 .../tests/fixtures/fs/peek_crlf.subm | 0 .../tests/fixtures/fs/read_bytes_range.subm | 0 .../tests/fixtures/fs/remove_recursive.subm | 0 .../tests/fixtures/fs/root_is_not_a_target.ts | 0 .../tests/fixtures/fs/stat_kinds.subm | 0 .../tests/fixtures/fs/text_write_read.subm | 0 .../tests/fixtures/fs/writer_basic.subm | 0 .../tests/fixtures/fs/writer_bytes.subm | 0 .../tests/fixtures/function_as_value.subm | 0 .../fixtures/function_identity_cross_package/app/main.ts | 0 .../fixtures/function_identity_cross_package/lib/extra.ts | 0 .../fixtures/function_identity_cross_package/lib/lib.ts | 0 .../fixtures/function_identity_cross_package/mid/lib.ts | 0 .../function_identity_cross_package/packages.manifest | 0 .../tests/fixtures/function_type_rendering_round_trip.ts | 0 .../tests/fixtures/function_type_renders_parseable.ts | 0 .../tests/fixtures/function_typed_array_elements.ts | 0 .../tests/fixtures/generic_arg_accepts_subclass.ts | 0 .../fixtures/generic_call_infers_common_supertype.ts | 0 .../fixtures/generic_call_infers_from_expected_union.ts | 0 .../tests/fixtures/generic_type_argument_variance.ts | 0 .../fixtures/generics/array_push_aliased_function.subm | 0 .../fixtures/generics/array_sort_aliased_object.subm | 0 .../tests/fixtures/generics/call_void_return_type_arg.ts | 0 .../generics/callback_parameter_wider_than_element.ts | 0 .../fixtures/generics/captured_typevar_union_boxed.ts | 0 .../tests/fixtures/generics/class_box_basic.ts | 0 .../tests/fixtures/generics/class_closure_typed_field.ts | 0 .../fixtures/generics/class_cross_package/app/main.ts | 0 .../fixtures/generics/class_cross_package/boxes/lib.ts | 0 .../generics/class_cross_package/packages.manifest | 0 .../generics/class_cross_package_chain/app/main.ts | 0 .../generics/class_cross_package_chain/lib/lib.ts | 0 .../generics/class_cross_package_chain/mid/lib.ts | 0 .../generics/class_cross_package_chain/packages.manifest | 0 .../class_cross_package_closure_member/app/main.ts | 0 .../class_cross_package_closure_member/lib/lib.ts | 0 .../class_cross_package_closure_member/packages.manifest | 0 .../class_cross_package_generic_child/app/main.ts | 0 .../generics/class_cross_package_generic_child/lib/lib.ts | 0 .../class_cross_package_generic_child/packages.manifest | 0 .../class_cross_package_implicit_ctor/app/main.ts | 0 .../class_cross_package_implicit_ctor/base/lib.ts | 0 .../generics/class_cross_package_implicit_ctor/mid/lib.ts | 0 .../class_cross_package_implicit_ctor/packages.manifest | 0 .../generics/class_cross_package_interface/app/main.ts | 0 .../generics/class_cross_package_interface/lib/lib.ts | 0 .../class_cross_package_interface/packages.manifest | 0 .../generics/class_cross_package_namespace/app/main.ts | 0 .../generics/class_cross_package_namespace/lib/lib.ts | 0 .../class_cross_package_namespace/packages.manifest | 0 .../tests/fixtures/generics/class_erased_slot_abi.ts | 0 .../tests/fixtures/generics/class_error_subclass.ts | 0 .../fixtures/generics/class_extends_concrete_args.ts | 0 .../fixtures/generics/class_generic_extends_generic.ts | 0 .../tests/fixtures/generics/class_generic_field_rw.ts | 0 .../generics/class_implements_generic_interface.ts | 0 .../tests/fixtures/generics/class_infer_void_arg.ts | 0 .../tests/fixtures/generics/class_instanceof.ts | 0 .../tests/fixtures/generics/class_instanceof_subclass.ts | 0 .../fixtures/generics/class_object_literal_in_closure.ts | 0 .../tests/fixtures/generics/class_recursive_node.ts | 0 .../fixtures/generics/class_statics_optional_readonly.ts | 0 .../tests/fixtures/generics/class_this_in_closure.ts | 0 .../tests/fixtures/generics/class_two_params.ts | 0 .../tests/fixtures/generics/class_type_arg_shapes.ts | 0 .../generics/class_uninferred_type_param_is_unknown.ts | 0 .../tests/fixtures/generics/class_union_narrowing.ts | 0 .../tests/fixtures/generics/class_universal_slots.ts | 0 .../tests/fixtures/generics/class_void_type_arg.ts | 0 .../fixtures/generics/expect_error_arithmetic_on_t.subm | 0 .../fixtures/generics/expect_error_arity_mismatch.subm | 0 ...ct_error_callback_base_class_with_unbound_arguments.ts | 0 .../fixtures/generics/expect_error_class_arg_mismatch.ts | 0 .../fixtures/generics/expect_error_class_extends_arity.ts | 0 .../fixtures/generics/expect_error_class_generic_arity.ts | 0 .../generics/expect_error_class_implements_wrong_arg.ts | 0 .../generics/expect_error_class_instanceof_alias.ts | 0 .../generics/expect_error_class_instanceof_args.ts | 0 .../generics/expect_error_class_instanceof_impossible.ts | 0 .../generics/expect_error_class_method_generic.ts | 0 .../generics/expect_error_class_never_type_arg.ts | 0 .../generics/expect_error_class_static_type_param.ts | 0 .../generics/expect_error_concrete_into_generic_call.subm | 0 .../generics/expect_error_conflicting_bindings.subm | 0 .../generics/expect_error_cross_gp_assignment.subm | 0 .../fixtures/generics/expect_error_ctor_void_type_arg.ts | 0 .../generics/expect_error_first_class_generic.subm | 0 .../expect_error_generic_call_common_supertype.ts | 0 .../expect_error_generic_call_keeps_regular_literal.ts | 0 .../expect_error_generic_method_interface_literal.ts | 0 ...r_generic_object_argument_plain_value_keeps_literal.ts | 0 .../expect_error_generic_object_argument_slot_mismatch.ts | 0 .../expect_error_generic_variance_chain_back_to_root.ts | 0 ...xpect_error_generic_variance_growing_instantiations.ts | 0 .../generics/expect_error_inference_argument_priority.ts | 0 .../fixtures/generics/expect_error_interface_arity.subm | 0 .../generics/expect_error_method_never_type_arg.ts | 0 .../expect_error_recursion_assigns_concrete_to_t.subm | 0 .../generics/expect_error_recursion_returns_concrete.subm | 0 .../expect_error_uninferred_type_param_is_unknown.ts | 0 .../generics/expect_error_union_member_closely_matched.ts | 0 .../tests/fixtures/generics/explicit_type_args.subm | 0 .../tests/fixtures/generics/first.subm | 0 .../generics/generic_call_infers_from_nested_literals.ts | 0 .../fixtures/generics/generic_call_keeps_literal_type.ts | 0 .../generic_call_literal_candidates_form_union.ts | 0 .../generics/generic_call_nested_literal_arguments.ts | 0 .../generic_call_result_keeps_declared_literals.ts | 0 .../generics/generic_call_widens_fresh_literal.ts | 0 .../tests/fixtures/generics/generic_calls_generic.subm | 0 .../generic_covariant_void_argument_compares_members.ts | 0 .../fixtures/generics/generic_interface_annotation.subm | 0 ...generic_object_argument_infers_callback_fields_last.ts | 0 .../fixtures/generics/generic_object_round_trip.subm | 0 .../tests/fixtures/generics/generic_recursion.subm | 0 ...generic_result_literal_freshness_per_type_parameter.ts | 0 .../generic_tuple_argument_infers_elements_in_order.ts | 0 ...neric_union_parameter_infers_from_structured_member.ts | 0 .../generics/generic_union_parameter_naked_priority.ts | 0 .../fixtures/generics/generic_variance_measured_once.ts | 0 .../tests/fixtures/generics/identity.subm | 0 ...nference_through_interfaces_fields_and_nested_calls.ts | 0 .../tests/fixtures/generics/map_set_aliased_value.subm | 0 .../generics/nullish_candidates_infer_their_union.ts | 0 .../generics/object_literal_for_generic_interface.ts | 0 .../tests/fixtures/generics/recursion.subm | 0 .../tests/fixtures/generics/returns_generic_closure.subm | 0 .../tests/fixtures/generics/tostring_on_t.subm | 0 .../tests/fixtures/generics/tuple_return_generic_fn.ts | 0 .../generics/uninferred_type_param_is_unknown.subm | 0 .../generics/union_parameter_takes_what_others_leave.ts | 0 .../tests/fixtures/generics/unknown_runtime_descriptor.ts | 0 .../tests/fixtures/global_array_object_literal.subm | 0 .../tests/fixtures/higher_order_function.subm | 0 .../tests/fixtures/higher_order_no_literal.ts | 0 .../tests/fixtures/higher_order_with_capture.subm | 0 .../tests/fixtures/host_error_catchable.subm | 0 .../tests/fixtures/host_held_values_survive_collection.ts | 0 .../tests/fixtures/host_owned_vtables.ts | 0 .../tests/fixtures/host_string_struct_spike.ts | 0 .../errors/expect_error_download_options_extra_field.subm | 0 .../http/errors/expect_error_get_too_many_args.subm | 0 .../fixtures/http/errors/expect_error_get_with_body.subm | 0 .../http/errors/expect_error_headers_wrong_type.subm | 0 .../errors/expect_error_headers_wrong_value_type.subm | 0 .../http/errors/expect_error_post_body_wrong_type.subm | 0 .../http/errors/expect_error_response_unknown_method.subm | 0 .../errors/expect_error_response_unknown_property.subm | 0 .../tests/fixtures/http_dot_segments.ts | 0 .../tests/fixtures/imports/alias_named_from.ts | 0 .../imports/ancestor_only_static_closure/app/main.ts | 0 .../imports/ancestor_only_static_closure/lib/lib.ts | 0 .../ancestor_only_static_closure/packages.manifest | 0 .../tests/fixtures/imports/embedding_aliased.ts | 0 .../tests/fixtures/imports/embedding_named.ts | 0 .../tests/fixtures/imports/embedding_namespace.ts | 0 .../fixtures/imports/embedding_wildcard_namespace.ts | 0 .../fixtures/imports/errors/combined_default_named.subm | 0 .../tests/fixtures/imports/errors/duplicate_local.subm | 0 .../errors/expect_error_prelude_namespace_aliased.subm | 0 .../expect_error_prelude_namespace_star_aliased.subm | 0 .../tests/fixtures/imports/errors/export_default.subm | 0 .../imports/errors/export_inside_function_body.subm | 0 .../tests/fixtures/imports/errors/export_list.subm | 0 .../tests/fixtures/imports/errors/import_in_function.subm | 0 .../tests/fixtures/imports/errors/namespace_as_value.subm | 0 .../imports/errors/namespace_member_as_value.subm | 0 .../imports/errors/relative_import_escapes_root.subm | 0 .../imports/errors/relative_import_single_file.subm | 0 .../tests/fixtures/imports/errors/unknown_named.subm | 0 .../fixtures/imports/errors/unknown_namespace_member.subm | 0 .../tests/fixtures/imports/errors/unknown_package.subm | 0 .../imports/errors/uuid_namespace_not_auto_imported.subm | 0 .../fixtures/imports/errors/uuid_not_auto_imported.subm | 0 .../tests/fixtures/imports/export_modifier_ignored.subm | 0 .../fixtures/imports/http_namespace_optional_args.subm | 0 .../imports/import_prelude_namespace_forgiven.subm | 0 .../imports/import_prelude_namespace_star_forgiven.subm | 0 .../tests/fixtures/imports/llm_aliased.ts | 0 .../tests/fixtures/imports/llm_named.ts | 0 .../tests/fixtures/imports/llm_namespace.ts | 0 .../tests/fixtures/imports/llm_package_caller/app/main.ts | 0 .../fixtures/imports/llm_package_caller/packages.manifest | 0 .../fixtures/imports/llm_package_caller/triage/lib.ts | 0 .../tests/fixtures/imports/llm_wildcard_namespace.ts | 0 .../tests/fixtures/imports/security_check_basic.subm | 0 .../fixtures/imports/security_check_chain/app/main.ts | 0 .../fixtures/imports/security_check_chain/inner/lib.ts | 0 .../fixtures/imports/security_check_chain/outer/lib.ts | 0 .../imports/security_check_chain/packages.manifest | 0 .../imports/security_check_closure_callback/app/main.ts | 0 .../imports/security_check_closure_callback/inner/lib.ts | 0 .../imports/security_check_closure_callback/outer/lib.ts | 0 .../security_check_closure_callback/packages.manifest | 0 .../tests/fixtures/imports/security_check_denied.ts | 0 .../tests/fixtures/imports/security_check_namespace.subm | 0 .../tests/fixtures/imports/session_aliased.ts | 0 .../tests/fixtures/imports/session_named.ts | 0 .../tests/fixtures/imports/session_namespace.ts | 0 .../fixtures/imports/session_package_caller/app/main.ts | 0 .../imports/session_package_caller/packages.manifest | 0 .../fixtures/imports/session_package_caller/store/lib.ts | 0 .../tests/fixtures/imports/session_wildcard_namespace.ts | 0 .../tests/fixtures/imports/uuid_aliased.subm | 0 .../tests/fixtures/imports/uuid_named.subm | 0 .../tests/fixtures/imports/uuid_namespace.subm | 0 .../tests/fixtures/imports/uuid_v7.subm | 0 .../tests/fixtures/imports/uuid_wildcard_namespace.subm | 0 .../tests/fixtures/inferred_closure_return_widening.ts | 0 .../tests/fixtures/inferred_literal_extra_fields.ts | 0 .../tests/fixtures/infinity_nan_parameter_defaults.ts | 0 .../tests/fixtures/inherited_method_lift_substitutes.ts | 0 .../tests/fixtures/initializer_narrowing.ts | 0 .../tests/fixtures/initializer_union_shapes.ts | 0 .../tests/fixtures/interface_to_string.ts | 0 .../tests/fixtures/interface_value_capture.subm | 0 .../interface_value_into_nullable_object_return.ts | 0 .../tests/fixtures/interface_value_into_object_slot.ts | 0 .../fixtures/interfaces/expansive_recursive_assign.ts | 0 .../interfaces/expect_error_bad_member_separator.ts | 0 .../expect_error_expansive_recursive_mismatch.ts | 0 .../interfaces/expect_error_finite_recursive_mismatch.ts | 0 .../expect_error_method_interface_from_object.subm | 0 .../expect_error_user_interface_missing_member.subm | 0 .../expect_error_user_interface_missing_method.subm | 0 .../expect_error_user_interface_wrong_method_type.subm | 0 .../fixtures/interfaces/interface_property_no_literal.ts | 0 .../tests/fixtures/interfaces/single_line_members.ts | 0 .../interfaces/structural_object_interface_assign.subm | 0 .../interfaces/user_interface_decl_typechecks.subm | 0 .../tests/fixtures/interfaces/user_interface_factory.subm | 0 .../fixtures/interfaces/user_interface_nested_field.subm | 0 .../fixtures/interfaces/user_interface_property_read.subm | 0 .../interfaces/user_interface_value_method_call.subm | 0 .../tests/fixtures/is_array.subm | 0 .../tests/fixtures/is_primitive.subm | 0 .../tests/fixtures/issue_1147_array_capacity.ts | 0 .../tests/fixtures/issue_1147_push_compatibility.ts | 0 .../tests/fixtures/issue_821/functions.ts | 0 .../tests/fixtures/issue_821/optional_functions.ts | 0 .../tests/fixtures/issue_821/top_level_function.ts | 0 .../tests/fixtures/issue_831/cycles.ts | 0 .../tests/fixtures/issue_831/mixed_cycles.ts | 0 .../tests/fixtures/issue_836/number_format.ts | 0 .../tests/fixtures/issue_844/null_algebra.ts | 0 .../tests/fixtures/issue_844/null_keys.ts | 0 .../tests/fixtures/issue_872/array_discriminant.ts | 0 .../tests/fixtures/issue_872/array_guard_boundaries.ts | 0 .../fixtures/issue_899/expect_error_distinct_enums.ts | 0 .../tests/fixtures/issue_899/primitive_enum.ts | 0 .../tests/fixtures/issue_965/global_call_reassignment.ts | 0 .../tests/fixtures/issue_966/insert_optional.ts | 0 .../tests/fixtures/issue_966/inserted_fields_json.ts | 0 .../tests/fixtures/issue_966/insertion_during_write.ts | 0 .../fixtures/issue_966/insertion_preserves_guards.ts | 0 .../tests/fixtures/issue_968/conditional_loop_writes.ts | 0 .../tests/fixtures/issue_968/nested_loop_writes.ts | 0 .../tests/fixtures/issue_970/accessor_enumeration.ts | 0 .../issue_regressions/compound_literal_operands.ts | 0 .../issue_regressions/conditional_literal_results.ts | 0 .../tests/fixtures/issue_regressions/disjunction_guard.ts | 0 .../fixtures/issue_regressions/enum_literal_equality.ts | 0 ...expect_error_compound_assign_receiver_reported_once.ts | 0 .../expect_error_conditional_spread_type.ts | 0 .../expect_error_disjoint_literal_equality.ts | 0 .../issue_regressions/expect_error_disjunction_partial.ts | 0 .../expect_error_explicit_void_return.ts | 0 .../expect_error_finally_break_missing_return.ts | 0 .../expect_error_literal_false_branch.ts | 0 .../expect_error_missing_prelude_members.ts | 0 .../expect_error_negative_literal_equality.ts | 0 .../expect_error_nested_finally_break.ts | 0 .../issue_regressions/expect_error_nested_switch_break.ts | 0 .../expect_error_optional_spread_type.ts | 0 .../expect_error_polymorphic_contravariance.ts | 0 .../expect_error_polymorphic_mismatch.ts | 0 .../issue_regressions/expect_error_switch_try_falls.ts | 0 .../fixtures/issue_regressions/finally_break_return.ts | 0 .../fixtures/issue_regressions/finite_alias_depth.ts | 0 .../tests/fixtures/issue_regressions/literal_equality.ts | 0 .../issue_regressions/literal_equality_aliases.ts | 0 .../fixtures/issue_regressions/logical_interpolation.ts | 0 .../issue_regressions/nested_polymorphic_alias.ts | 0 .../tests/fixtures/issue_regressions/nullable_equality.ts | 0 .../tests/fixtures/issue_regressions/object_spread.ts | 0 .../issue_regressions/object_spread_integration.ts | 0 .../fixtures/issue_regressions/object_spread_overrides.ts | 0 .../fixtures/issue_regressions/object_spread_presence.ts | 0 .../fixtures/issue_regressions/polymorphic_covariance.ts | 0 .../fixtures/issue_regressions/signed_literal_equality.ts | 0 .../fixtures/issue_regressions/switch_try_termination.ts | 0 .../tests/fixtures/issue_regressions/void_callback.ts | 0 .../tests/fixtures/iterators/close_called_on_break.subm | 0 .../fixtures/iterators/close_called_on_exhaustion.subm | 0 .../tests/fixtures/iterators/close_called_on_throw.subm | 0 .../iterators/iterable_each_loop_closes_own_cursor.subm | 0 .../tests/fixtures/iterators/iterable_hand_rolled.subm | 0 .../tests/fixtures/iterators/iterator_break.subm | 0 .../tests/fixtures/iterators/iterator_continue.subm | 0 .../tests/fixtures/iterators/iterator_hand_rolled.subm | 0 .../tests/fixtures/iterators/iterator_nullable_t.subm | 0 .../tests/fixtures/iterators/no_close_no_crash.subm | 0 .../tests/fixtures/iterators/user_interface_iterable.subm | 0 .../tests/fixtures/json/expect_error_bare_json.subm | 0 .../tests/fixtures/json/expect_error_let_json_parse.subm | 0 .../fixtures/json/expect_error_parse_function_target.subm | 0 .../json/expect_error_parse_too_many_type_args.subm | 0 .../json/expect_error_parse_type_args_and_as.subm | 0 .../json/expect_error_parse_uint8array_target.subm | 0 .../tests/fixtures/json/expect_error_partial_json.subm | 0 .../fixtures/json/expect_error_stringify_replacer.ts | 0 .../fixtures/json/expect_error_stringify_type_args.subm | 0 .../json/expect_error_to_json_wrong_signature.subm | 0 .../fixtures/json/expect_error_to_json_wrong_type.subm | 0 .../fixtures/json/expect_error_unknown_json_member.subm | 0 .../tests/fixtures/json/interface_optional_omitted.ts | 0 .../tests/fixtures/json/main_array_return.subm | 0 .../tests/fixtures/json/main_object_return.subm | 0 .../tests/fixtures/json/parse_array_of_literal.subm | 0 .../tests/fixtures/json/parse_array_of_numbers.subm | 0 .../tests/fixtures/json/parse_array_of_objects.subm | 0 .../tests/fixtures/json/parse_array_of_strings.subm | 0 .../tests/fixtures/json/parse_array_of_tuples.subm | 0 .../tests/fixtures/json/parse_array_of_union.subm | 0 .../tests/fixtures/json/parse_as_cast.subm | 0 .../tests/fixtures/json/parse_bool.subm | 0 .../fixtures/json/parse_diagnostic_preview_path.subm | 0 .../tests/fixtures/json/parse_explicit_generic.subm | 0 .../tests/fixtures/json/parse_field_union.subm | 0 .../tests/fixtures/json/parse_inferred_interface.ts | 0 .../tests/fixtures/json/parse_into_generic_interface.subm | 0 .../tests/fixtures/json/parse_into_interface.subm | 0 .../tests/fixtures/json/parse_into_interface_nested.subm | 0 .../fixtures/json/parse_into_recursive_interface.subm | 0 .../tests/fixtures/json/parse_invalid_throws.subm | 0 .../tests/fixtures/json/parse_mismatch_throws.subm | 0 .../tests/fixtures/json/parse_nested.subm | 0 .../tests/fixtures/json/parse_null.subm | 0 .../tests/fixtures/json/parse_number.subm | 0 .../tests/fixtures/json/parse_number_literal_target.subm | 0 .../tests/fixtures/json/parse_object_equals_hash.subm | 0 .../tests/fixtures/json/parse_object_lenient.subm | 0 .../tests/fixtures/json/parse_object_literal_field.subm | 0 .../tests/fixtures/json/parse_object_nullable_field.subm | 0 .../tests/fixtures/json/parse_object_optional_field.subm | 0 .../tests/fixtures/json/parse_object_round_trip.subm | 0 .../tests/fixtures/json/parse_object_simple.subm | 0 .../fixtures/json/parse_recursive_discriminated.subm | 0 .../tests/fixtures/json/parse_recursive_linked_list.subm | 0 .../tests/fixtures/json/parse_recursive_object.subm | 0 .../tests/fixtures/json/parse_recursive_union.subm | 0 .../tests/fixtures/json/parse_string.subm | 0 .../tests/fixtures/json/parse_string_literal_target.subm | 0 .../tests/fixtures/json/parse_t_or_null.subm | 0 .../tests/fixtures/json/parse_tuple_basic.subm | 0 .../tests/fixtures/json/parse_tuple_in_object.subm | 0 .../tests/fixtures/json/parse_tuple_literal_position.subm | 0 .../tests/fixtures/json/parse_tuple_nested.subm | 0 .../tests/fixtures/json/parse_tuple_round_trip.subm | 0 .../tests/fixtures/json/parse_union_literal_set.subm | 0 .../tests/fixtures/json/parse_union_mixed_tags.subm | 0 .../tests/fixtures/json/parse_union_primitive.subm | 0 .../tests/fixtures/json/parse_union_shared_tag.subm | 0 .../tests/fixtures/json/parse_union_status_code.subm | 0 .../tests/fixtures/json/parse_union_tagged.subm | 0 .../tests/fixtures/json/parse_union_untagged.subm | 0 .../tests/fixtures/json/stringify_array.subm | 0 .../tests/fixtures/json/stringify_as_string.subm | 0 .../tests/fixtures/json/stringify_bool.subm | 0 .../json/stringify_interface_array_round_trip.subm | 0 .../json/stringify_interface_optional_field_assigned.ts | 0 .../tests/fixtures/json/stringify_negative_zero.subm | 0 .../tests/fixtures/json/stringify_null.subm | 0 .../json/stringify_null_valued_nullable_field.subm | 0 .../tests/fixtures/json/stringify_nullable_number.subm | 0 .../tests/fixtures/json/stringify_nullable_object.subm | 0 .../tests/fixtures/json/stringify_nullable_string.subm | 0 .../tests/fixtures/json/stringify_number.subm | 0 .../tests/fixtures/json/stringify_object.subm | 0 .../fixtures/json/stringify_object_optional_field.subm | 0 .../tests/fixtures/json/stringify_pretty_eval_order.ts | 0 .../tests/fixtures/json/stringify_pretty_space_number.ts | 0 .../tests/fixtures/json/stringify_pretty_space_string.ts | 0 .../tests/fixtures/json/stringify_string.subm | 0 .../tests/fixtures/json/to_json_direct.subm | 0 .../tests/fixtures/json/to_json_field_override.subm | 0 .../json/to_json_field_override_with_capture.subm | 0 .../tests/fixtures/json/to_json_via_generic.subm | 0 .../tests/fixtures/json_parse_lone_surrogate.ts | 0 .../tests/fixtures/json_stringify_collection.ts | 0 .../tests/fixtures/json_stringify_erased_null.ts | 0 .../tests/fixtures/json_stringify_reassigned_field.ts | 0 .../tests/fixtures/json_stringify_width_subtype.ts | 0 .../tests/fixtures/json_utf16_lossless.ts | 0 .../fixtures/later_module_variable_shadows_namespace.ts | 0 .../tests/fixtures/let_keeps_regular_literal_types.ts | 0 .../tests/fixtures/linear_regex_output.ts | 0 .../tests/fixtures/linear_string_transforms.ts | 0 .../tests/fixtures/literal_keeping_operators.ts | 0 .../fixtures/literal_own_type_keeps_binding_writable.ts | 0 .../tests/fixtures/literal_own_type_under_annotation.ts | 0 .../tests/fixtures/literal_type_capture.subm | 0 .../tests/fixtures/literal_type_number.subm | 0 .../tests/fixtures/literal_type_string.subm | 0 .../tests/fixtures/literal_type_union.subm | 0 .../tests/fixtures/literal_union_interface_field.ts | 0 .../tests/fixtures/llm_basic.ts | 0 .../tests/fixtures/llm_batch_ordering.ts | 0 .../tests/fixtures/llm_batch_partial_failure.ts | 0 .../tests/fixtures/llm_budget_aggregate.ts | 0 .../tests/fixtures/llm_budget_per_execution.ts | 0 .../tests/fixtures/llm_budget_release_after_trap.ts | 0 .../tests/fixtures/llm_call_erased.ts | 0 .../tests/fixtures/llm_call_unknown.ts | 0 .../tests/fixtures/llm_denied.ts | 0 .../tests/fixtures/llm_error_taxonomy.ts | 0 .../tests/fixtures/llm_models_all_callable.ts | 0 .../tests/fixtures/llm_models_empty.ts | 0 .../tests/fixtures/llm_models_filtered.ts | 0 .../tests/fixtures/llm_models_no_description.ts | 0 .../tests/fixtures/llm_no_provider.ts | 0 .../tests/fixtures/llm_prompt_bounds.ts | 0 .../tests/fixtures/llm_schema_argument_rejected.ts | 0 .../tests/fixtures/llm_schema_unsupported.ts | 0 .../tests/fixtures/llm_typed_get.ts | 0 .../tests/fixtures/llm_typed_mismatch.ts | 0 .../tests/fixtures/llm_typed_provider_ignored_schema.ts | 0 .../tests/fixtures/loop_condition_write_narrows.ts | 0 .../tests/fixtures/loop_empty_body.ts | 0 .../fixtures/loops/body_scope_vs_synthesized_stmts.ts | 0 .../tests/fixtures/loops/do_while_break.subm | 0 .../tests/fixtures/loops/do_while_continue.ts | 0 .../tests/fixtures/loops/do_while_once.subm | 0 .../tests/fixtures/loops/do_while_truthiness_cond.subm | 0 .../loops/errors/expect_error_break_outside_loop.subm | 0 .../loops/errors/expect_error_continue_outside_loop.subm | 0 .../loops/errors/expect_error_for_of_non_array.subm | 0 .../tests/fixtures/loops/for_basic.subm | 0 .../tests/fixtures/loops/for_break.subm | 0 .../tests/fixtures/loops/for_continue.subm | 0 .../tests/fixtures/loops/for_empty_slots.subm | 0 .../tests/fixtures/loops/for_let_per_iteration_binding.ts | 0 .../tests/fixtures/loops/for_nested.subm | 0 .../tests/fixtures/loops/for_of_break.subm | 0 .../tests/fixtures/loops/for_of_continue.subm | 0 .../tests/fixtures/loops/for_of_empty.subm | 0 .../tests/fixtures/loops/for_of_number_array.subm | 0 .../tests/fixtures/loops/for_of_string_array.subm | 0 .../tests/fixtures/loops/for_of_tuple.ts | 0 .../tests/fixtures/loops/for_truthiness_cond.subm | 0 .../tests/fixtures/map_for_each.subm | 0 .../tests/fixtures/map_from_differing_tuple_literals.ts | 0 .../tests/fixtures/map_set_from_iterable.ts | 0 .../tests/fixtures/map_set_identity.ts | 0 .../tests/fixtures/maps/basic_string_keys.subm | 0 .../tests/fixtures/maps/cached_hashes_and_ledger.ts | 0 .../tests/fixtures/maps/ctor_from_entries.subm | 0 .../fixtures/maps/expect_error_for_of_non_iterable.subm | 0 .../tests/fixtures/maps/expect_error_record_type.ts | 0 .../tests/fixtures/maps/expect_error_weakmap_type.subm | 0 .../tests/fixtures/maps/expect_error_weakmap_value.subm | 0 .../tests/fixtures/maps/expect_error_weakset_type.subm | 0 .../tests/fixtures/maps/expect_error_weakset_value.subm | 0 .../tests/fixtures/maps/host_port_roundtrip.ts | 0 .../tests/fixtures/maps/insertion_order.subm | 0 .../tests/fixtures/maps/insertion_order_after_resize.subm | 0 .../fixtures/maps/insertion_order_delete_middle.subm | 0 .../tests/fixtures/maps/insertion_order_set.subm | 0 .../fixtures/maps/insertion_order_set_after_resize.subm | 0 .../fixtures/maps/insertion_order_set_delete_middle.subm | 0 .../tests/fixtures/maps/iterate_for_of.subm | 0 .../tests/fixtures/maps/iterate_iterator_method.subm | 0 .../tests/fixtures/maps/iterate_set_iterator_method.subm | 0 .../tests/fixtures/maps/iterator_concurrent.subm | 0 .../tests/fixtures/maps/iterator_sees_later_sets.subm | 0 .../fixtures/maps/keys_values_entries_iterators.subm | 0 .../tests/fixtures/maps/number_keys.subm | 0 .../tests/fixtures/maps/object_keys.subm | 0 .../fixtures/maps/object_values_get_field_access.subm | 0 .../tests/fixtures/maps/phase2_typecheck.subm | 0 .../tests/fixtures/maps/phase6_for_of_typecheck.subm | 0 .../tests/fixtures/maps/postfix_chain_on_new.subm | 0 .../tests/fixtures/maps/resize.subm | 0 .../tests/fixtures/maps/set_basic.subm | 0 .../tests/fixtures/maps/set_ctor_from_values.subm | 0 .../tests/fixtures/maps/set_host_port_roundtrip.ts | 0 .../tests/fixtures/maps/set_iterate.subm | 0 .../fixtures/maps/set_keys_values_entries_iterators.subm | 0 .../tests/fixtures/maps/tombstone_reclamation.ts | 0 .../tests/fixtures/maps/tombstone_reuse.subm | 0 .../tests/fixtures/math_basic.subm | 0 .../tests/fixtures/math_constants.subm | 0 .../tests/fixtures/math_hypot.subm | 0 .../tests/fixtures/math_pi.subm | 0 .../tests/fixtures/math_random.subm | 0 .../tests/fixtures/math_transcendentals.subm | 0 .../tests/fixtures/method_call_through_string_key.ts | 0 .../fixtures/method_lift_substitutes_receiver_args.ts | 0 .../module_let_narrowing_reads_live_after_call.ts | 0 .../fixtures/module_variable_before_initialization.ts | 0 .../tests/fixtures/multi/aliased_enum_import/lib.ts | 0 .../tests/fixtures/multi/aliased_enum_import/m_enum.ts | 0 .../fixtures/multi/default_param_cross_module/lib.ts | 0 .../fixtures/multi/default_param_cross_module/util.ts | 0 .../tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts | 0 .../fixtures/multi/errors/ambiguous_ts_subm/wrap.subm | 0 .../tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts | 0 .../tests/fixtures/multi/errors/cycle/b.subm | 0 .../tests/fixtures/multi/errors/cycle/lib.subm | 0 .../tests/fixtures/multi/errors/main_decl/lib.subm | 0 .../tests/fixtures/multi/errors/missing_module/lib.subm | 0 .../errors/module_exported_function_private_type/lib.subm | 0 .../module_exported_function_private_type/util.subm | 0 .../errors/module_exported_global_private_type/lib.subm | 0 .../errors/module_exported_global_private_type/util.subm | 0 .../errors/module_exported_type_private_type/lib.subm | 0 .../errors/module_exported_type_private_type/util.subm | 0 .../package_exported_function_private_type/lib.subm | 0 .../package_exported_function_private_type/util.subm | 0 .../errors/package_exported_type_private_type/lib.subm | 0 .../errors/package_exported_type_private_type/util.subm | 0 .../lib.subm | 0 .../util.subm | 0 .../lib.subm | 0 .../util.subm | 0 .../tests/fixtures/multi/errors/private_symbol/lib.subm | 0 .../tests/fixtures/multi/errors/private_symbol/util.subm | 0 .../fixtures/multi/exported_docs_direct_documented/lib.ts | 0 .../fixtures/multi/exported_docs_direct_missing/lib.ts | 0 .../fixtures/multi/exported_docs_interface_member/lib.ts | 0 .../fixtures/multi/exported_docs_internal_helper/lib.ts | 0 .../fixtures/multi/exported_docs_reexport_missing/lib.ts | 0 .../fixtures/multi/exported_docs_reexport_missing/util.ts | 0 .../fixtures/multi/exported_docs_sibling_only/lib.ts | 0 .../fixtures/multi/exported_docs_sibling_only/util.ts | 0 .../multi/exported_function_type_surface/lib.subm | 0 .../multi/exported_function_type_surface/util.subm | 0 .../tests/fixtures/multi/namespace_import/lib.subm | 0 .../tests/fixtures/multi/namespace_import/util.subm | 0 .../package_reexported_recursive_type_surface/lib.subm | 0 .../package_reexported_recursive_type_surface/util.subm | 0 .../tests/fixtures/multi/reexport_basic/lib.subm | 0 .../tests/fixtures/multi/reexport_basic/util.subm | 0 .../fixtures/multi/reserved_word_export_names/lib.ts | 0 .../fixtures/multi/reserved_word_export_names/values.ts | 0 .../tests/fixtures/multi/sibling_import/lib.subm | 0 .../tests/fixtures/multi/sibling_import/util.subm | 0 .../multi/signature_lift_unimported_receiver_type/lib.ts | 0 .../signature_lift_unimported_receiver_type/widget.ts | 0 .../tests/fixtures/multi/ts_mixed/lib.ts | 0 .../tests/fixtures/multi/ts_mixed/wrap.subm | 0 .../tests/fixtures/multi/type_only_reexport/lib.ts | 0 .../tests/fixtures/multi/type_only_reexport/util.ts | 0 .../multi/union_write_help_unimported_member/lib.ts | 0 .../multi/union_write_help_unimported_member/widget.ts | 0 .../tests/fixtures/mvp_greet.subm | 0 .../tests/fixtures/namespace_shadowed_by_top_level.ts | 0 .../tests/fixtures/nan_local_binding_not_flagged.ts | 0 .../tests/fixtures/narrowed_boxed_binding_read.ts | 0 .../tests/fixtures/narrowing/aliased_conditions_narrow.ts | 0 .../tests/fixtures/narrowing/array_isarray_narrows.subm | 0 .../fixtures/narrowing/array_isarray_on_generic.subm | 0 .../fixtures/narrowing/assign_narrow_then_rewiden.ts | 0 .../fixtures/narrowing/assign_narrowing_survives_join.ts | 0 .../fixtures/narrowing/assign_narrows_block_tail.subm | 0 .../fixtures/narrowing/assign_sibling_invalidates.subm | 0 .../fixtures/narrowing/assign_then_call_invalidates.subm | 0 .../fixtures/narrowing/assignment_value_truthiness.ts | 0 .../narrowing/back_edge_narrowing_not_at_entry.ts | 0 .../narrowing/call_preserves_identifier_narrowing.subm | 0 .../narrowing/call_preserves_property_path_narrowing.subm | 0 .../tests/fixtures/narrowing/call_rereads_field_path.ts | 0 .../fixtures/narrowing/captured_mutator_write_back.ts | 0 .../tests/fixtures/narrowing/chained_short_circuit.subm | 0 .../tests/fixtures/narrowing/class_field_and_chain.ts | 0 .../tests/fixtures/narrowing/class_field_nested_if.ts | 0 .../fixtures/narrowing/class_private_field_same_module.ts | 0 .../tests/fixtures/narrowing/closure_last_assignment.ts | 0 .../fixtures/narrowing/closure_reguards_field_path.ts | 0 .../narrowing/computed_write_retains_literal_type.ts | 0 .../narrowing/const_narrow_closure_for_of_const.ts | 0 .../narrowing/const_narrow_closure_nested_arrow.ts | 0 .../narrowing/const_narrow_closure_param_shadow.ts | 0 .../narrowing/const_narrow_closure_returns_later.ts | 0 .../fixtures/narrowing/const_narrow_closure_top_level.ts | 0 .../narrowing/const_narrow_closure_typeof_unknown.ts | 0 .../fixtures/narrowing/const_narrow_survives_closure.ts | 0 .../fixtures/narrowing/discriminant_kind_equality.subm | 0 .../fixtures/narrowing/discriminant_kind_inequality.subm | 0 .../tests/fixtures/narrowing/discriminant_member_sets.ts | 0 .../fixtures/narrowing/discriminant_three_variants.subm | 0 .../fixtures/narrowing/do_while_back_edge_wraps_body.ts | 0 .../tests/fixtures/narrowing/dropped_index_path_hint.ts | 0 .../tests/fixtures/narrowing/enum_discriminant_case.ts | 0 .../enum_exclusions_reach_switch_and_predicate.ts | 0 .../narrowing/enum_exclusions_survive_other_checks.ts | 0 .../narrowing/enum_tuple_and_variable_discriminants.ts | 0 .../tests/fixtures/narrowing/equality_between_unions.ts | 0 .../exhaustive_switch_after_stale_narrowing_throws.ts | 0 ...ct_error_aliased_condition_needs_constant_reference.ts | 0 .../narrowing/expect_error_assign_narrowing_leaves_try.ts | 0 .../expect_error_assignment_narrow_in_closure.ts | 0 .../expect_error_assignment_value_truthiness_rules_out.ts | 0 .../expect_error_back_edge_narrowing_at_entry.ts | 0 .../narrowing/expect_error_captured_mutating_let.subm | 0 .../expect_error_computed_key_guard_written_by_name.ts | 0 .../expect_error_destructured_parameter_reassigned.ts | 0 .../narrowing/expect_error_do_while_continue_widens.ts | 0 .../expect_error_enum_exclusions_keep_unchecked_member.ts | 0 .../expect_error_equal_to_type_parameter_keeps_null.ts | 0 .../expect_error_equality_keeps_overlapping_objects.ts | 0 .../expect_error_field_path_narrow_in_closure.ts | 0 ...rror_field_with_every_member_ruled_out_is_not_never.ts | 0 .../fixtures/narrowing/expect_error_flow_catch_throw.ts | 0 .../narrowing/expect_error_flow_continue_write.ts | 0 .../fixtures/narrowing/expect_error_flow_field_do.ts | 0 .../fixtures/narrowing/expect_error_flow_field_for.ts | 0 .../fixtures/narrowing/expect_error_flow_field_forof.ts | 0 .../fixtures/narrowing/expect_error_flow_field_while.ts | 0 .../fixtures/narrowing/expect_error_flow_finally_break.ts | 0 .../fixtures/narrowing/expect_error_flow_local_direct.ts | 0 .../fixtures/narrowing/expect_error_flow_local_nested.ts | 0 .../fixtures/narrowing/expect_error_flow_local_switch.ts | 0 .../fixtures/narrowing/expect_error_flow_local_try.ts | 0 .../narrowing/expect_error_flow_root_reassignment.ts | 0 .../tests/fixtures/narrowing/expect_error_flow_update.ts | 0 .../narrowing/expect_error_flow_zero_reachable_do.ts | 0 .../narrowing/expect_error_flow_zero_reachable_for.ts | 0 .../narrowing/expect_error_flow_zero_reachable_forof.ts | 0 .../narrowing/expect_error_flow_zero_reachable_while.ts | 0 .../narrowing/expect_error_for_update_continue_widens.ts | 0 .../expect_error_function_union_assignment_short_call.ts | 0 .../expect_error_generic_member_is_not_a_discriminant.ts | 0 .../tests/fixtures/narrowing/expect_error_getter_path.ts | 0 .../fixtures/narrowing/expect_error_getter_path_cast.ts | 0 .../fixtures/narrowing/expect_error_getter_path_index.ts | 0 .../fixtures/narrowing/expect_error_getter_path_prefix.ts | 0 .../narrowing/expect_error_in_operator_primitive_rhs.subm | 0 .../narrowing/expect_error_index_by_changing_key.ts | 0 .../narrowing/expect_error_let_narrow_in_closure.ts | 0 .../expect_error_missing_return_in_narrow_region.subm | 0 .../expect_error_module_let_written_by_function.ts | 0 .../narrowing/expect_error_more_narrowing_hints.ts | 0 .../expect_error_never_array_element_keeps_its_type.ts | 0 .../narrowing/expect_error_nominal_union_reads.ts | 0 .../fixtures/narrowing/expect_error_nullable_rw_target.ts | 0 .../narrowing/expect_error_operator_narrowing_hint.ts | 0 .../narrowing/expect_error_param_narrow_in_closure.ts | 0 ...xpect_error_property_path_field_write_invalidates.subm | 0 .../expect_error_reassign_same_type_kills_guard.ts | 0 .../expect_error_rejected_write_keeps_declared_type.ts | 0 .../expect_error_switch_last_clause_runs_off_end.ts | 0 .../expect_error_switch_no_match_exit_narrows.ts | 0 .../expect_error_unreachable_code_reads_declared_types.ts | 0 .../expect_error_unreachable_in_narrow_region.subm | 0 .../narrowing/expect_error_user_guard_body_unsound.subm | 0 .../expect_error_user_guard_generic_unsound.subm | 0 .../narrowing/expect_error_user_guard_in_alias.subm | 0 .../narrowing/expect_error_user_guard_not_param.subm | 0 .../expect_error_user_guard_type_alias_unsound.subm | 0 .../expect_error_write_still_invalidates_after_call.subm | 0 .../fixtures/narrowing/field_path_two_deep_structural.ts | 0 .../tests/fixtures/narrowing/flow_clause_joins.ts | 0 .../tests/fixtures/narrowing/flow_condition_preserved.ts | 0 .../tests/fixtures/narrowing/flow_do_break.ts | 0 .../fixtures/narrowing/flow_for_condition_preserved.ts | 0 .../tests/fixtures/narrowing/flow_join_820.ts | 0 .../tests/fixtures/narrowing/flow_join_898.ts | 0 .../tests/fixtures/narrowing/flow_join_901.ts | 0 .../tests/fixtures/narrowing/flow_join_902.ts | 0 .../tests/fixtures/narrowing/flow_loops.ts | 0 .../tests/fixtures/narrowing/flow_numeric_source.ts | 0 .../tests/fixtures/narrowing/flow_switch_unmatched.ts | 0 .../tests/fixtures/narrowing/flow_this_for.ts | 0 .../fixtures/narrowing/for_cond_narrow_wraps_body.ts | 0 .../narrowing/for_loop_mutated_let_null_guard_number.subm | 0 .../narrowing/for_loop_mutated_let_null_guard_string.subm | 0 .../fixtures/narrowing/for_of_back_edge_wraps_body.ts | 0 .../narrowing/for_of_body_local_continue_narrow.ts | 0 .../fixtures/narrowing/for_of_loop_var_continue_narrow.ts | 0 .../fixtures/narrowing/for_update_runs_on_back_edge.ts | 0 .../tests/fixtures/narrowing/function_union_assignment.ts | 0 .../tests/fixtures/narrowing/generic_class_box_of_box.ts | 0 .../tests/fixtures/narrowing/global_field_paths.ts | 0 .../tests/fixtures/narrowing/global_guard_mutation.ts | 0 .../tests/fixtures/narrowing/global_ternary_null.ts | 0 .../tests/fixtures/narrowing/guard_through_an_element.ts | 0 .../fixtures/narrowing/immediately_invoked_functions.ts | 0 .../fixtures/narrowing/in_operator_basic_object.subm | 0 .../tests/fixtures/narrowing/in_operator_dynamic_key.ts | 0 .../fixtures/narrowing/in_operator_union_filter.subm | 0 .../fixtures/narrowing/in_operator_unknown_chain.subm | 0 .../tests/fixtures/narrowing/in_typeof_field_chain.subm | 0 .../tests/fixtures/narrowing/index_by_constant_key.ts | 0 .../tests/fixtures/narrowing/index_path_and_chain.ts | 0 .../fixtures/narrowing/interface_field_holding_class.ts | 0 .../tests/fixtures/narrowing/issue_785_chain.ts | 0 .../narrowing/issue_785_expect_error_null_chain.ts | 0 .../tests/fixtures/narrowing/issue_785_switch.ts | 0 .../tests/fixtures/narrowing/issue_786.ts | 0 .../fixtures/narrowing/issue_786_expect_error_shadow.ts | 0 .../tests/fixtures/narrowing/issue_816.ts | 0 .../tests/fixtures/narrowing/issue_889.ts | 0 .../narrowing/issue_889_expect_error_arrow_guard.ts | 0 .../tests/fixtures/narrowing/issue_890_anonymous_lift.ts | 0 .../tests/fixtures/narrowing/issue_890_predicate_lift.ts | 0 .../tests/fixtures/narrowing/issue_929.ts | 0 .../fixtures/narrowing/issue_929_expect_error_union.ts | 0 .../tests/fixtures/narrowing/issue_948.ts | 0 .../tests/fixtures/narrowing/issue_948_composed.ts | 0 .../tests/fixtures/narrowing/issue_948_discriminant.ts | 0 .../tests/fixtures/narrowing/issue_948_nested.ts | 0 .../tests/fixtures/narrowing/issue_948_switch.ts | 0 .../tests/fixtures/narrowing/issue_948_union_refined.ts | 0 .../fixtures/narrowing/join_points_keep_narrowing.ts | 0 .../narrowing/literal_equality_chain_rules_out.ts | 0 .../narrowing/literal_equality_excludes_nullish.ts | 0 .../tests/fixtures/narrowing/literal_index_guard.ts | 0 .../tests/fixtures/narrowing/live_assignment_result.ts | 0 .../tests/fixtures/narrowing/live_big_bom.ts | 0 .../tests/fixtures/narrowing/live_big_separator.ts | 0 .../fixtures/narrowing/live_boolean_literal_result.ts | 0 .../tests/fixtures/narrowing/live_call_order.ts | 0 .../tests/fixtures/narrowing/live_function_reference.ts | 0 .../tests/fixtures/narrowing/live_index_conversion.ts | 0 .../tests/fixtures/narrowing/live_index_noncanonical.ts | 0 .../tests/fixtures/narrowing/live_json_arguments.ts | 0 .../tests/fixtures/narrowing/live_map_return.ts | 0 .../tests/fixtures/narrowing/live_member_builtin_rest.ts | 0 .../tests/fixtures/narrowing/live_member_class_rest.ts | 0 .../tests/fixtures/narrowing/live_member_default.ts | 0 .../tests/fixtures/narrowing/live_member_fresh_default.ts | 0 .../fixtures/narrowing/live_member_function_default.ts | 0 .../tests/fixtures/narrowing/live_member_rest.ts | 0 .../tests/fixtures/narrowing/live_number_predicate.ts | 0 .../fixtures/narrowing/live_optional_shape_analysis.ts | 0 .../narrowing/live_package_array_argument/app/main.ts | 0 .../narrowing/live_package_array_argument/library/lib.ts | 0 .../live_package_array_argument/packages.manifest | 0 .../narrowing/live_package_callback_parameter/app/main.ts | 0 .../live_package_callback_parameter/library/lib.ts | 0 .../live_package_callback_parameter/packages.manifest | 0 .../narrowing/live_package_function_reference/app/main.ts | 0 .../live_package_function_reference/library/lib.ts | 0 .../live_package_function_reference/packages.manifest | 0 .../narrowing/live_package_imported_global/app/main.ts | 0 .../narrowing/live_package_imported_global/library/lib.ts | 0 .../live_package_imported_global/packages.manifest | 0 .../narrowing/live_package_object_argument/app/main.ts | 0 .../narrowing/live_package_object_argument/library/lib.ts | 0 .../live_package_object_argument/packages.manifest | 0 .../narrowing/live_package_returned_closure/app/main.ts | 0 .../live_package_returned_closure/library/lib.ts | 0 .../live_package_returned_closure/packages.manifest | 0 .../narrowing/live_package_setter_parameter/app/main.ts | 0 .../live_package_setter_parameter/library/lib.ts | 0 .../live_package_setter_parameter/packages.manifest | 0 .../tests/fixtures/narrowing/live_postfix_value.ts | 0 .../tests/fixtures/narrowing/live_pow_boundary.ts | 0 .../tests/fixtures/narrowing/live_pow_nan.ts | 0 .../tests/fixtures/narrowing/live_receiver_generic.ts | 0 .../tests/fixtures/narrowing/live_receiver_includes.ts | 0 .../tests/fixtures/narrowing/live_receiver_length.ts | 0 .../tests/fixtures/narrowing/live_receiver_method.ts | 0 .../tests/fixtures/narrowing/live_receiver_optional.ts | 0 .../tests/fixtures/narrowing/live_receiver_to_string.ts | 0 .../tests/fixtures/narrowing/live_regex_argument.ts | 0 .../tests/fixtures/narrowing/live_runtime_values.ts | 0 .../tests/fixtures/narrowing/live_search_order.ts | 0 .../tests/fixtures/narrowing/live_string_argument.ts | 0 .../tests/fixtures/narrowing/live_valueof_conversion.ts | 0 .../fixtures/narrowing/live_values_packages/app/main.ts | 0 .../narrowing/live_values_packages/library/lib.ts | 0 .../narrowing/live_values_packages/packages.manifest | 0 .../tests/fixtures/narrowing/loop_exit_body_local_join.ts | 0 .../loop_head_keeps_narrowing_when_body_returns.ts | 0 .../tests/fixtures/narrowing/loop_join_after_continue.ts | 0 .../tests/fixtures/narrowing/loop_tail_narrowings.ts | 0 .../tests/fixtures/narrowing/loop_wrapped_body_forms.ts | 0 .../fixtures/narrowing/mixed_union_typeof_plus_kind.subm | 0 ...le_let_written_by_function_narrows_within_statement.ts | 0 .../tests/fixtures/narrowing/nested_block_narrowing.subm | 0 .../tests/fixtures/narrowing/nested_shadow_reuse.ts | 0 .../narrowing/never_array_hints_later_elements.ts | 0 .../fixtures/narrowing/never_field_in_object_literal.ts | 0 .../fixtures/narrowing/never_operand_in_dead_code.ts | 0 .../tests/fixtures/narrowing/never_read_in_closure.ts | 0 .../fixtures/narrowing/nominal_union_field_access.ts | 0 .../tests/fixtures/narrowing/non_null_assertion.ts | 0 .../narrowing/non_null_receiver_preserves_path.ts | 0 .../tests/fixtures/narrowing/not_truthiness_narrow.subm | 0 .../tests/fixtures/narrowing/null_comparison_guards.ts | 0 .../tests/fixtures/narrowing/null_eq_else.subm | 0 .../tests/fixtures/narrowing/null_global_narrow.subm | 0 .../tests/fixtures/narrowing/null_neq_then.subm | 0 .../tests/fixtures/narrowing/null_neq_unbox.subm | 0 .../fixtures/narrowing/nullable_rw_target_write_out.ts | 0 .../tests/fixtures/narrowing/nullable_smoke.subm | 0 .../tests/fixtures/narrowing/operator_narrowing.ts | 0 .../narrowing/optional_field_eq_null_post_if.subm | 0 .../narrowing/optional_field_neq_null_narrows.subm | 0 .../tests/fixtures/narrowing/postfix_narrowed.ts | 0 .../fixtures/narrowing/property_path_chained_post_if.subm | 0 .../narrowing/property_path_discriminant_post_if.subm | 0 .../property_path_discriminant_three_variants.subm | 0 .../property_path_discriminant_view_on_field.subm | 0 .../tests/fixtures/narrowing/property_path_eq_else.subm | 0 .../tests/fixtures/narrowing/property_path_neq_then.subm | 0 .../narrowing/property_path_neq_then_post_if.subm | 0 .../fixtures/narrowing/reassign_same_type_rewidens.ts | 0 .../fixtures/narrowing/return_in_if_carries_narrow.subm | 0 .../tests/fixtures/narrowing/rules_out_every_value.ts | 0 .../fixtures/narrowing/short_circuit_and_narrows.subm | 0 .../fixtures/narrowing/short_circuit_or_narrows.subm | 0 .../fixtures/narrowing/sibling_paths_mixed_chain_len.ts | 0 .../fixtures/narrowing/sibling_paths_three_idents.ts | 0 .../fixtures/narrowing/switch_boolean_discriminant.ts | 0 .../narrowing/switch_default_reads_never_on_any_path.ts | 0 .../narrowing/switch_wide_discriminant_falls_through.ts | 0 .../narrowing/switch_without_default_falls_through.ts | 0 .../fixtures/narrowing/ternary_and_interface_field.ts | 0 .../tests/fixtures/narrowing/this_rooted_paths.ts | 0 .../fixtures/narrowing/throw_in_if_carries_narrow.subm | 0 .../fixtures/narrowing/truthiness_field_path_narrow.subm | 0 .../tests/fixtures/narrowing/truthiness_narrow.subm | 0 .../narrowing/tuple_union_literal_discriminator.subm | 0 .../narrowing/tuple_union_typeof_discriminator.subm | 0 .../tests/fixtures/narrowing/typeof_aliased_union.subm | 0 .../tests/fixtures/narrowing/typeof_boolean_narrow.subm | 0 .../fixtures/narrowing/typeof_field_path_else_branch.subm | 0 .../fixtures/narrowing/typeof_field_path_string.subm | 0 .../narrowing/typeof_folded_operand_still_runs.ts | 0 .../tests/fixtures/narrowing/typeof_function_generic.subm | 0 .../tests/fixtures/narrowing/typeof_function_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_number_narrow.subm | 0 .../fixtures/narrowing/typeof_object_and_enum_tags.ts | 0 .../tests/fixtures/narrowing/typeof_object_generic.subm | 0 .../tests/fixtures/narrowing/typeof_object_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_string_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_three_way_union.subm | 0 .../fixtures/narrowing/typeof_through_generic_alias.ts | 0 .../tests/fixtures/narrowing/user_guard_discriminant.subm | 0 .../tests/fixtures/narrowing/user_guard_else_branch.subm | 0 .../user_guard_generic_non_generic_asserted.subm | 0 .../fixtures/narrowing/user_guard_generic_strip_null.subm | 0 .../tests/fixtures/narrowing/user_guard_in_typeof.subm | 0 .../tests/fixtures/narrowing/user_guard_nullable.subm | 0 .../tests/fixtures/narrowing/user_guard_primitive.subm | 0 .../tests/fixtures/narrowing/user_guard_type_alias.subm | 0 .../narrowing/while_body_local_continue_narrow.ts | 0 .../tests/fixtures/narrowing/while_body_narrowing.subm | 0 .../fixtures/narrowing/while_break_carries_narrow.subm | 0 .../fixtures/narrowing/while_break_two_paths_widens.subm | 0 .../fixtures/narrowing/while_fixed_point_continue.subm | 0 .../fixtures/narrowing/while_fixed_point_converges.subm | 0 .../tests/fixtures/narrowing_field_path_nested_region.ts | 0 .../tests/fixtures/nested_function_default_param.ts | 0 .../tests/fixtures/nested_function_reads_later_local.ts | 0 .../tests/fixtures/nested_function_top_level_block.ts | 0 .../fixtures/never/expect_error_never_falls_through.subm | 0 .../never/expect_error_return_value_in_never_fn.subm | 0 .../never/expect_error_value_into_never_slot.subm | 0 .../tests/fixtures/never/never_assignable_to_string.subm | 0 .../tests/fixtures/never/never_in_union.subm | 0 .../tests/fixtures/never/never_return_throw.subm | 0 .../fixtures/never_annotated_closure_in_void_slot.ts | 0 .../tests/fixtures/never_function_void_slot.ts | 0 .../tests/fixtures/never_generic_callback.ts | 0 .../tests/fixtures/never_operands.ts | 0 .../tests/fixtures/new_uint8array.subm | 0 .../tests/fixtures/new_with_dotted_form.subm | 0 .../tests/fixtures/no_panic_prelude_invariants.ts | 0 .../non_null_assert_on_null_narrowing_reads_declared.ts | 0 .../tests/fixtures/null_discriminant_narrows.ts | 0 .../tests/fixtures/nullable_receiver_names_the_guard.ts | 0 .../tests/fixtures/nullish_coalescing/chained.subm | 0 .../nullish_coalescing/coalesce_null_typed_left.ts | 0 .../nullish_coalescing/expect_error_mix_with_and.subm | 0 .../nullish_coalescing/expect_error_mix_with_or.subm | 0 .../tests/fixtures/nullish_coalescing/simple.subm | 0 .../tests/fixtures/nullish_coalescing/void_right.ts | 0 .../tests/fixtures/nullish_coalescing/with_field.subm | 0 .../tests/fixtures/nullish_coalescing/with_parens_ok.subm | 0 .../tests/fixtures/nullish_grouping_and_zero_literals.ts | 0 .../tests/fixtures/number_global_predicates.subm | 0 .../tests/fixtures/number_parse_statics.subm | 0 .../tests/fixtures/number_predicates_no_coercion.ts | 0 .../tests/fixtures/number_radix_strings.subm | 0 .../tests/fixtures/number_static_constants.subm | 0 .../tests/fixtures/number_static_predicates.subm | 0 .../tests/fixtures/number_to_fixed.subm | 0 .../tests/fixtures/number_to_precision_exponential.subm | 0 .../tests/fixtures/number_to_string_radix.subm | 0 .../fixtures/numeric_separators_and_decimal_point.ts | 0 .../tests/fixtures/object_function_typed_field.subm | 0 .../tests/fixtures/object_is.subm | 0 .../tests/fixtures/object_key_reassigned_wider_field.ts | 0 .../tests/fixtures/object_literal_dictionary_union.ts | 0 .../tests/fixtures/object_literal_evaluation_order.ts | 0 .../fixtures/object_literal_into_nullable_tagged_union.ts | 0 .../fixtures/object_literal_normalization_at_depth.ts | 0 .../tests/fixtures/object_literal_subtype_reduction.ts | 0 .../tests/fixtures/object_rest_copies.ts | 0 .../tests/fixtures/object_rest_let.ts | 0 .../tests/fixtures/object_spread_widened_union.ts | 0 .../tests/fixtures/object_statics.subm | 0 .../tests/fixtures/object_statics_host.ts | 0 .../tests/fixtures/object_type_member_named_new.ts | 0 .../absent_optional_property_with_sibling_accessor.ts | 0 .../objects/expect_error_field_assign_missing_field.subm | 0 .../objects/expect_error_field_assign_non_object.subm | 0 .../objects/expect_error_field_assign_type_mismatch.subm | 0 .../expect_error_fresh_literal_extra_annotated.subm | 0 .../objects/expect_error_fresh_literal_extra_return.subm | 0 .../objects/expect_error_invalid_assign_target.subm | 0 .../expect_error_optional_not_assignable_to_required.subm | 0 ...t_error_optional_not_assignable_to_value_nullable.subm | 0 .../objects/expect_error_union_missing_field.subm | 0 .../expect_error_unknown_string_bracket_field.subm | 0 ...t_error_value_nullable_not_assignable_to_optional.subm | 0 .../tests/fixtures/objects/field_assign_basic.subm | 0 .../fixtures/objects/field_assign_const_binding.subm | 0 .../tests/fixtures/objects/field_assign_nested.subm | 0 .../tests/fixtures/objects/field_assign_string.subm | 0 .../tests/fixtures/objects/interface_field_assignment.ts | 0 .../fixtures/objects/interface_property_write_dispatch.ts | 0 .../tests/fixtures/objects/multiline_object_literal.subm | 0 .../tests/fixtures/objects/nullable_eq_literal.subm | 0 .../tests/fixtures/objects/nullable_field_literal.subm | 0 .../tests/fixtures/objects/optional_field_literal.subm | 0 .../fixtures/objects/optional_field_null_compare.subm | 0 .../tests/fixtures/objects/optional_present_null.ts | 0 .../tests/fixtures/objects/optional_undefined_presence.ts | 0 .../tests/fixtures/objects/property_shorthand.subm | 0 .../tests/fixtures/objects/quoted_property_names.subm | 0 .../fixtures/objects/reserved_keyword_property_names.subm | 0 .../tests/fixtures/objects/union_field_access.subm | 0 .../tests/fixtures/objects/widen_to_nullable_field.subm | 0 .../tests/fixtures/objects/width_sub_array.subm | 0 .../tests/fixtures/objects/width_sub_assign.subm | 0 .../tests/fixtures/objects/width_sub_basic.subm | 0 .../fixtures/objects/width_sub_intermediate_arg.subm | 0 .../tests/fixtures/objects/width_sub_nested.subm | 0 .../tests/fixtures/optional_chain_near_limit.ts | 0 .../fixtures/optional_chain_non_nullable_receiver.ts | 0 .../fixtures/optional_chain_nullable_host_property.ts | 0 .../tests/fixtures/optional_chain_string_key.ts | 0 .../optional_chaining/chain_nullable_step_fixes.ts | 0 .../fixtures/optional_chaining/chain_then_coalesce.subm | 0 .../optional_chaining/expect_error_chain_nullable_step.ts | 0 .../expect_error_optional_call_binding.ts | 0 .../expect_error_optional_method_reference.ts | 0 .../expect_error_optional_null_receiver.ts | 0 .../expect_error_optional_unknown_receiver.ts | 0 .../tests/fixtures/optional_chaining/field_chain.subm | 0 .../fixtures/optional_chaining/multiple_optional.subm | 0 .../fixtures/optional_chaining/nested_field_chain.subm | 0 .../tests/fixtures/optional_chaining/non_null_division.ts | 0 .../fixtures/optional_chaining/non_null_void_result.ts | 0 .../tests/fixtures/optional_chaining/optional_call.subm | 0 .../optional_chaining/optional_call_defaults_and_rest.ts | 0 .../optional_chaining/optional_call_nullable_return.ts | 0 .../fixtures/optional_chaining/optional_class_accessor.ts | 0 .../fixtures/optional_chaining/optional_class_field.ts | 0 .../optional_chaining/optional_class_field_chain.ts | 0 .../fixtures/optional_chaining/optional_generic_method.ts | 0 .../tests/fixtures/optional_chaining/optional_index.subm | 0 .../fixtures/optional_chaining/optional_index_bounds.ts | 0 .../optional_chaining/optional_inherited_field.ts | 0 .../optional_chaining/optional_interface_accessor.ts | 0 .../optional_chaining/optional_interface_property.subm | 0 .../tests/fixtures/optional_chaining/optional_method.subm | 0 .../optional_chaining/optional_method_nullable_return.ts | 0 .../fixtures/optional_chaining/optional_narrowed_step.ts | 0 .../optional_chaining/optional_non_null_continuation.ts | 0 .../optional_chaining/optional_object_prelude_member.ts | 0 .../optional_chaining/optional_primitive_receiver.ts | 0 .../optional_chaining/optional_redundant_primitive.ts | 0 .../fixtures/optional_chaining/optional_union_field.ts | 0 .../fixtures/optional_chaining/optional_void_method.subm | 0 .../fixtures/optional_chaining/void_result_bindings.ts | 0 .../fixtures/optional_field_written_null_serializes.ts | 0 .../tests/fixtures/optional_to_json_property.ts | 0 .../tests/fixtures/optional_to_string_property.ts | 0 .../fixtures/override_narrows_return_with_finally.ts | 0 .../tests/fixtures/override_returns_into_narrower_slot.ts | 0 .../tests/fixtures/override_slot_variance.ts | 0 .../fixtures/override_variance_cross_package/app/main.ts | 0 .../fixtures/override_variance_cross_package/base/lib.ts | 0 .../fixtures/override_variance_cross_package/child/lib.ts | 0 .../override_variance_cross_package/packages.manifest | 0 .../fixtures/package_rules/capability_binding_key/lib.ts | 0 .../package_rules/capability_binding_paths_resolve/lib.ts | 0 .../capability_binding_paths_resolve/types.ts | 0 .../fixtures/package_rules/capability_dynamic_name/lib.ts | 0 .../fixtures/package_rules/capability_extra_tag/lib.ts | 0 .../fixtures/package_rules/capability_missing_tag/lib.ts | 0 .../package_rules/capability_nonliteral_payload/lib.ts | 0 .../fixtures/package_rules/capability_payload_key/lib.ts | 0 .../package_rules/capability_unknown_field/lib.ts | 0 .../package_rules/capability_unknown_field/types.ts | 0 .../package_rules/capability_unknown_parameter/lib.ts | 0 .../fixtures/package_rules/class_member_bodies/lib.ts | 0 .../fixtures/package_rules/class_missing_return/lib.ts | 0 .../package_rules/class_switch_fallthrough/lib.ts | 0 .../fixtures/package_rules/class_unreachable_code/lib.ts | 0 .../fixtures/package_rules/doc_callable_members/lib.ts | 0 .../tests/fixtures/package_rules/doc_consistency/lib.ts | 0 .../package_rules/enum_dependency_exhaustive/app/main.ts | 0 .../enum_dependency_exhaustive/consumer/lib.ts | 0 .../enum_dependency_exhaustive/levels/lib.ts | 0 .../enum_dependency_exhaustive/packages.manifest | 0 .../package_rules/enum_other_module_exhaustive/levels.ts | 0 .../package_rules/enum_other_module_exhaustive/lib.ts | 0 .../package_rules/enum_other_module_exhaustive/shades.ts | 0 .../tests/fixtures/package_rules/missing_return/lib.ts | 0 .../fixtures/package_rules/switch_fallthrough/lib.ts | 0 .../tests/fixtures/package_rules/top_level_return/lib.ts | 0 .../fixtures/package_rules/unassigned_class_field/lib.ts | 0 .../tests/fixtures/package_rules/unreachable_code/lib.ts | 0 .../class_member_object_literal_cross_package/app/main.ts | 0 .../class_member_object_literal_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../packages/closure_param_cross_package/app/main.ts | 0 .../packages/closure_param_cross_package/host/lib.ts | 0 .../closure_param_cross_package/packages.manifest | 0 .../closure_sig_inherited_from_dependency/app/main.ts | 0 .../closure_sig_inherited_from_dependency/base/lib.ts | 0 .../packages.manifest | 0 .../fixtures/packages/const_ref_cross_package/app/main.ts | 0 .../fixtures/packages/const_ref_cross_package/cfg/lib.ts | 0 .../packages/const_ref_cross_package/packages.manifest | 0 .../interface_dispatch_in_declaring_package/app/main.ts | 0 .../interface_dispatch_in_declaring_package/lib/lib.ts | 0 .../packages.manifest | 0 .../packages/recursive_alias_cross_package/app/main.ts | 0 .../packages/recursive_alias_cross_package/lib/lib.ts | 0 .../recursive_alias_cross_package/packages.manifest | 0 .../parameter_defaults_reference_earlier_parameters.ts | 0 .../fixtures/parameter_literal_union_default_write.ts | 0 .../tests/fixtures/parse_int_radix_undefined.ts | 0 .../tests/fixtures/postfix_incdec/inc_dec_basic.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_bigint.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_captured.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_field.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_for_loop.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_global.subm | 0 .../fixtures/postfix_incdec/inc_dec_in_expression.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_index.subm | 0 .../property_regressions/expect_error_in_nullable.ts | 0 .../expect_error_inherited_write_only.ts | 0 .../expect_error_optional_write_only.ts | 0 .../expect_error_write_only_assignment.ts | 0 .../expect_error_write_only_implements.ts | 0 .../tests/fixtures/property_regressions/in_accessors.ts | 0 .../fixtures/property_regressions/in_erased_presence.ts | 0 .../tests/fixtures/property_regressions/in_presence.ts | 0 .../fixtures/property_regressions/inherited_accessors.ts | 0 .../property_regressions/interface_json_surrogates.ts | 0 .../fixtures/property_regressions/interface_postfix.ts | 0 .../property_regressions/interface_wide_mutation.ts | 0 .../property_regressions/postfix_package/app/main.ts | 0 .../property_regressions/postfix_package/lib/lib.ts | 0 .../postfix_package/packages.manifest | 0 .../fixtures/property_regressions/recursive_mutation.ts | 0 .../property_regressions/required_undefined_round_trip.ts | 0 .../fixtures/property_regressions/required_unknown.ts | 0 .../tests/fixtures/radix_number_literals.subm | 0 .../fixtures/readonly/assignment_narrows_to_value_type.ts | 0 .../readonly/expect_error_readonly_array_writes.ts | 0 .../expect_error_readonly_field_shown_in_object_type.ts | 0 .../fixtures/readonly/expect_error_readonly_non_array.ts | 0 .../readonly/expect_error_readonly_survives_narrowing.ts | 0 .../expect_error_readonly_survives_value_shape.ts | 0 .../fixtures/readonly/expect_error_readonly_to_mutable.ts | 0 .../readonly/getonly_cannot_implement_writable.ts | 0 .../tests/fixtures/readonly/inline_object_runtime.ts | 0 .../readonly/interface_property_write_rejected.ts | 0 .../readonly/object_type_property_write_rejected.ts | 0 .../tests/fixtures/readonly/readonly_array_reads.ts | 0 .../tests/fixtures/readonly/writable_property_write_ok.ts | 0 .../tests/fixtures/readonly_cast_qualifiers.ts | 0 .../tests/fixtures/readonly_rest_parameter.ts | 0 .../tests/fixtures/readonly_rest_parameter_write.ts | 0 .../tests/fixtures/readonly_string_length.subm | 0 .../tests/fixtures/records/cross_package/app/main.ts | 0 .../tests/fixtures/records/cross_package/lib/lib.ts | 0 .../fixtures/records/cross_package/packages.manifest | 0 .../tests/fixtures/records/indexed_growth_and_equality.ts | 0 .../tests/fixtures/records/optional_dynamic_presence.ts | 0 .../tests/fixtures/records/record_accessors.ts | 0 .../tests/fixtures/records/record_bad_computed_spread.ts | 0 .../tests/fixtures/records/record_basic.ts | 0 .../tests/fixtures/records/record_checked_reads.ts | 0 .../tests/fixtures/records/record_class_guards.ts | 0 .../tests/fixtures/records/record_conditional_spread.ts | 0 .../tests/fixtures/records/record_errors.ts | 0 .../tests/fixtures/records/record_evaluation.ts | 0 .../tests/fixtures/records/record_features.ts | 0 .../tests/fixtures/records/record_forward_index.ts | 0 .../tests/fixtures/records/record_function_receiver.ts | 0 .../fixtures/records/record_generic_contract_errors.ts | 0 .../fixtures/records/record_generic_method_errors.ts | 0 .../tests/fixtures/records/record_generic_methods.ts | 0 .../tests/fixtures/records/record_inherit_composition.ts | 0 .../fixtures/records/record_inherit_composition_errors.ts | 0 .../tests/fixtures/records/record_inherit_conflicts.ts | 0 .../fixtures/records/record_inherit_forward_alias.ts | 0 .../tests/fixtures/records/record_inherit_members.ts | 0 .../tests/fixtures/records/record_inherit_narrow.ts | 0 .../tests/fixtures/records/record_interface_reads.ts | 0 .../tests/fixtures/records/record_literal_writes.ts | 0 .../tests/fixtures/records/record_postfix_checked.ts | 0 .../tests/fixtures/records/record_recursive.ts | 0 .../fixtures/records/record_recursive_interface_error.ts | 0 .../tests/fixtures/records/record_structural_write.ts | 0 .../tests/fixtures/records/record_unions.ts | 0 .../tests/fixtures/recursive-types/alias_linked_list.subm | 0 .../recursive-types/alias_polymorphic_recursion.ts | 0 .../tests/fixtures/recursive-types/alias_through_array.ts | 0 .../recursive-types/alias_through_generic_call.ts | 0 .../tests/fixtures/recursive-types/alias_tree.subm | 0 .../tests/fixtures/recursive-types/alias_union_json.subm | 0 .../fixtures/recursive-types/interface_resolution.subm | 0 .../tests/fixtures/regex_exec_basic.subm | 0 .../tests/fixtures/regex_flags_all.subm | 0 .../tests/fixtures/regex_input_cache.ts | 0 .../tests/fixtures/regex_lastindex_non_global.subm | 0 .../tests/fixtures/regex_lastindex_sticky.subm | 0 .../tests/fixtures/regex_literal_basic.subm | 0 .../tests/fixtures/regex_named_captures.subm | 0 .../tests/fixtures/regex_named_captures_unmatched.ts | 0 .../tests/fixtures/regex_non_ascii_literal.ts | 0 .../tests/fixtures/regex_numbered_captures.subm | 0 .../tests/fixtures/regex_per_site_lastindex.subm | 0 .../tests/fixtures/regex_property_reads.subm | 0 .../tests/fixtures/regex_shared_input.ts | 0 .../tests/fixtures/regex_test_basic.subm | 0 .../tests/fixtures/regex_test_lastindex_global.subm | 0 .../tests/fixtures/regex_to_string.subm | 0 .../tests/fixtures/regex_utf16_offsets.ts | 0 .../tests/fixtures/regexp_invalid_flags_type.ts | 0 .../fixtures/regexp_match_keeps_lone_surrogates.subm | 0 .../tests/fixtures/regexp_missing_source.ts | 0 .../tests/fixtures/regexp_optional_flags.ts | 0 .../tests/fixtures/regexp_replace_split_match_js.ts | 0 .../tests/fixtures/regexp_shorthand_classes_match_js.ts | 0 .../regexp_split_unmatched_capture_is_undefined.ts | 0 .../tests/fixtures/rejected_field_write_rhs_hint.ts | 0 .../tests/fixtures/rest_callback_for_fixed_arity.ts | 0 .../tests/fixtures/rest_param_arrow.subm | 0 .../tests/fixtures/rest_param_basic.subm | 0 .../tests/fixtures/rest_param_generic.subm | 0 .../tests/fixtures/rest_param_mixed.subm | 0 .../tests/fixtures/return_paths_void_union_and_getters.ts | 0 .../tests/fixtures/secrets_main_denied.ts | 0 .../tests/fixtures/session_basic.ts | 0 .../tests/fixtures/session_cursor_length_budget.ts | 0 .../tests/fixtures/session_denied.ts | 0 .../tests/fixtures/session_get_erased.ts | 0 .../tests/fixtures/session_get_mismatch.ts | 0 .../tests/fixtures/session_get_unknown.ts | 0 .../tests/fixtures/session_list.ts | 0 .../tests/fixtures/session_list_cursor_is_sealed.ts | 0 .../tests/fixtures/session_list_filtered.ts | 0 .../tests/fixtures/session_remove_denied.ts | 0 .../tests/fixtures/session_surrogate_fidelity.ts | 0 .../tests/fixtures/session_typed_get.ts | 0 .../tests/fixtures/session_unsupported_value.ts | 0 .../tests/fixtures/set_algebra.subm | 0 .../tests/fixtures/set_iteration_parity.subm | 0 .../tests/fixtures/set_relations.subm | 0 .../tests/fixtures/shared_serializer_buffer.ts | 0 .../tests/fixtures/spread/array_basic.subm | 0 .../tests/fixtures/spread/array_empty_source.subm | 0 .../tests/fixtures/spread/array_only_spreads.subm | 0 .../spread/err_array_spread_element_mismatch.subm | 0 .../tests/fixtures/spread/err_array_spread_non_array.subm | 0 .../fixtures/spread/err_object_spread_interface.subm | 0 .../fixtures/spread/err_object_spread_non_object.subm | 0 .../tests/fixtures/spread/object_basic.subm | 0 .../tests/fixtures/spread/object_multiple_spreads.subm | 0 .../fixtures/spread/object_override_literal_after.subm | 0 .../fixtures/spread/object_override_literal_before.subm | 0 .../tests/fixtures/spread_index_signature_union.ts | 0 .../tests/fixtures/spread_into_discriminated_union.ts | 0 .../tests/fixtures/spread_of_conditional_or_union.ts | 0 .../tests/fixtures/spread_of_falsy_value.ts | 0 .../tests/fixtures/spread_union_assigned_back.ts | 0 .../tests/fixtures/static_binding_as_value.ts | 0 .../fixtures/strict_mode_reserved_words_as_properties.ts | 0 .../tests/fixtures/string_admitted_builders.ts | 0 .../tests/fixtures/string_at_nullable.ts | 0 .../tests/fixtures/string_case.subm | 0 .../tests/fixtures/string_char_at.subm | 0 .../tests/fixtures/string_code_point_at_out_of_range.ts | 0 .../tests/fixtures/string_concat.subm | 0 .../tests/fixtures/string_for_of.subm | 0 .../tests/fixtures/string_from_char_code.subm | 0 .../tests/fixtures/string_from_char_code_wraps.ts | 0 .../tests/fixtures/string_from_code_point.subm | 0 .../tests/fixtures/string_index_of.subm | 0 .../tests/fixtures/string_key_member_access.ts | 0 .../tests/fixtures/string_length.subm | 0 .../tests/fixtures/string_linear_search.ts | 0 .../tests/fixtures/string_literal_lone_surrogates.ts | 0 .../tests/fixtures/string_match_all.subm | 0 .../tests/fixtures/string_match_and_search.subm | 0 .../tests/fixtures/string_multiline_raw_newline.ts | 0 .../tests/fixtures/string_normalize.subm | 0 .../tests/fixtures/string_of_null.ts | 0 .../tests/fixtures/string_ops_keep_lone_surrogates.ts | 0 .../tests/fixtures/string_or_array_union_methods.ts | 0 .../tests/fixtures/string_ordering.subm | 0 .../tests/fixtures/string_pad.subm | 0 .../tests/fixtures/string_repeat.subm | 0 .../tests/fixtures/string_repeat_negative.subm | 0 .../tests/fixtures/string_replace.subm | 0 .../tests/fixtures/string_replace_all.subm | 0 .../tests/fixtures/string_slice.subm | 0 .../tests/fixtures/string_split.subm | 0 .../tests/fixtures/string_starts_with.subm | 0 .../tests/fixtures/string_trim.subm | 0 .../tests/fixtures/string_well_formed.subm | 0 .../fixtures/structural_equals_cross_package/app/main.ts | 0 .../structural_equals_cross_package/packages.manifest | 0 .../structural_equals_cross_package/points/lib.ts | 0 .../tests/fixtures/structural_equals_shape_guard.ts | 0 .../tests/fixtures/structural_interfaces.subm | 0 .../tests/fixtures/structural_visit_budget.ts | 0 .../tests/fixtures/subclass_super_on_every_path.ts | 0 .../errors/expect_error_arrow_switch_fallthrough.ts | 0 .../expect_error_switch_assertNever_missing_variant.subm | 0 .../errors/expect_error_switch_case_type_mismatch.subm | 0 .../errors/expect_error_switch_continue_not_in_loop.subm | 0 .../switch/errors/expect_error_switch_duplicate_case.subm | 0 .../errors/expect_error_switch_duplicate_default.subm | 0 .../errors/expect_error_switch_enum_non_exhaustive.subm | 0 .../switch/errors/expect_error_switch_fallthrough.subm | 0 .../expect_error_switch_literal_union_non_exhaustive.subm | 0 .../expect_error_switch_multi_label_variant_field.subm | 0 .../errors/expect_error_switch_non_exhaustive_union.subm | 0 .../expect_error_switch_tuple_union_non_exhaustive.subm | 0 .../fixtures/switch/switch_assertNever_exhaustive.subm | 0 .../tests/fixtures/switch/switch_break_in_case.subm | 0 .../tests/fixtures/switch/switch_break_post_state.subm | 0 .../tests/fixtures/switch/switch_default_first.subm | 0 .../switch/switch_discriminated_union_narrowing.subm | 0 .../tests/fixtures/switch/switch_enum_discriminant.subm | 0 .../switch/switch_enum_exhaustive_no_default.subm | 0 .../fixtures/switch/switch_enum_exhaustive_string.subm | 0 .../switch/switch_inside_loop_break_targets_switch.subm | 0 .../switch/switch_inside_loop_continue_targets_loop.subm | 0 .../switch/switch_literal_union_default_narrows.subm | 0 .../fixtures/switch/switch_literal_union_exhaustive.subm | 0 .../tests/fixtures/switch/switch_multi_label.subm | 0 .../fixtures/switch/switch_multi_label_discriminated.subm | 0 .../fixtures/switch/switch_multi_label_literal_union.subm | 0 .../tests/fixtures/switch/switch_no_default.subm | 0 .../tests/fixtures/switch/switch_number_basic.subm | 0 .../tests/fixtures/switch/switch_return_in_case.subm | 0 .../tests/fixtures/switch/switch_string_basic.subm | 0 .../fixtures/switch/switch_tuple_union_exhaustive.subm | 0 .../fixtures/switch_case_body_recovery_no_panic.subm | 0 .../tests/fixtures/switch_case_hex_literal.subm | 0 .../switch_case_null_absent_field_stays_reachable.ts | 0 .../tests/fixtures/switch_expression_label_duplicates.ts | 0 .../tests/fixtures/switch_expression_labels.ts | 0 .../fixtures/switch_function_declarations_hoisted.ts | 0 .../tests/fixtures/switch_null_assignment_in_loop.ts | 0 .../tests/fixtures/switch_nullable.ts | 0 .../tests/fixtures/switch_signed_number_labels.ts | 0 .../tests/fixtures/syntax_nesting_near_limit.ts | 0 .../tests/fixtures/template_generic_null.ts | 0 .../tests/fixtures/template_literal_boolean.subm | 0 .../tests/fixtures/template_literal_interface.ts | 0 .../tests/fixtures/template_literal_nested.subm | 0 .../tests/fixtures/template_literal_no_substitution.subm | 0 .../tests/fixtures/template_literal_non_null_assert.ts | 0 .../tests/fixtures/template_literal_nullish.ts | 0 .../tests/fixtures/template_literal_number.subm | 0 .../tests/fixtures/template_literal_string.subm | 0 .../tests/fixtures/template_literal_tuple.ts | 0 .../tests/fixtures/template_nesting_near_limit.ts | 0 .../tests/fixtures/template_substitution_spans.ts | 0 .../fixtures/temporal/fields_bag_by_interface_type.ts | 0 .../tests/fixtures/temporal_compare.subm | 0 .../tests/fixtures/temporal_compare_sort.subm | 0 .../tests/fixtures/temporal_duration_arithmetic.subm | 0 .../tests/fixtures/temporal_duration_compare_from.subm | 0 .../tests/fixtures/temporal_duration_from_iso.subm | 0 .../tests/fixtures/temporal_duration_host_validation.ts | 0 .../tests/fixtures/temporal_duration_like_arg.subm | 0 .../tests/fixtures/temporal_duration_object_literal.subm | 0 .../tests/fixtures/temporal_duration_round_total.subm | 0 .../tests/fixtures/temporal_duration_sign.subm | 0 .../fixtures/temporal_duration_to_string_options.subm | 0 .../tests/fixtures/temporal_duration_with_abs_blank.subm | 0 .../tests/fixtures/temporal_duration_zdt_anchor.subm | 0 .../tests/fixtures/temporal_error_messages.subm | 0 .../tests/fixtures/temporal_errors_are_catchable.subm | 0 .../tests/fixtures/temporal_getters.subm | 0 .../tests/fixtures/temporal_hook_contract.ts | 0 .../tests/fixtures/temporal_instant_arithmetic.subm | 0 .../fixtures/temporal_instant_epoch_nanos_bigint.subm | 0 .../tests/fixtures/temporal_instant_equals.subm | 0 .../tests/fixtures/temporal_instant_from_epoch.subm | 0 .../tests/fixtures/temporal_instant_iso_round_trip.subm | 0 .../tests/fixtures/temporal_instant_round.subm | 0 .../tests/fixtures/temporal_long_duration.subm | 0 .../tests/fixtures/temporal_negative_duration.subm | 0 .../tests/fixtures/temporal_now_plain.subm | 0 .../tests/fixtures/temporal_now_smoke.subm | 0 .../tests/fixtures/temporal_now_time_zone_id.subm | 0 .../tests/fixtures/temporal_now_zoned_date_time_iso.subm | 0 .../tests/fixtures/temporal_numeric_range_validation.ts | 0 .../tests/fixtures/temporal_options_interface_arg.ts | 0 .../tests/fixtures/temporal_plain_arithmetic.subm | 0 .../tests/fixtures/temporal_plain_erased_boundaries.ts | 0 .../fixtures/temporal_plain_to_yearmonth_monthday.subm | 0 .../tests/fixtures/temporal_plain_to_zoned.subm | 0 .../tests/fixtures/temporal_plaindate.subm | 0 .../fixtures/temporal_plaindate_to_plaindatetime.subm | 0 .../tests/fixtures/temporal_plaindatetime.subm | 0 .../tests/fixtures/temporal_plainmonthday.subm | 0 .../tests/fixtures/temporal_plaintime.subm | 0 .../tests/fixtures/temporal_plainyearmonth.subm | 0 .../tests/fixtures/temporal_to_json.subm | 0 .../tests/fixtures/temporal_until_options.subm | 0 .../tests/fixtures/temporal_with.subm | 0 .../temporal_yearmonth_monthday_to_plaindate.subm | 0 .../tests/fixtures/temporal_zdt_alias_identity.ts | 0 .../tests/fixtures/temporal_zdt_dst_spring_forward.subm | 0 .../tests/fixtures/temporal_zdt_equals.subm | 0 .../tests/fixtures/temporal_zdt_from_iso.subm | 0 .../tests/fixtures/temporal_zdt_host_complete.ts | 0 .../fixtures/temporal_zdt_missing_member_diagnostic.subm | 0 .../tests/fixtures/temporal_zdt_to_instant.subm | 0 .../tests/fixtures/temporal_zdt_to_plain.subm | 0 .../tests/fixtures/temporal_zdt_with_time_zone.subm | 0 .../tests/fixtures/temporal_zoned_round_trip.subm | 0 .../fixtures/ternary/expect_error_missing_colon.subm | 0 .../tests/fixtures/ternary/logical_branches.ts | 0 .../tests/fixtures/ternary/narrowing.subm | 0 .../tests/fixtures/ternary/nested.subm | 0 .../tests/fixtures/ternary/simple.subm | 0 .../tests/fixtures/ternary/truthiness_cond.subm | 0 .../tests/fixtures/ternary/void_branches.ts | 0 .../tests/fixtures/ternary/with_optional_chain.subm | 0 .../tests/fixtures/text_codec_unicode.subm | 0 .../tests/fixtures/text_codec_with_base64.subm | 0 .../tests/fixtures/text_encoder_round_trip.subm | 0 .../tests/fixtures/to_json_record_non_string_throws.ts | 0 .../tests/fixtures/top_level_function_identity.ts | 0 .../tests/fixtures/tostring_default_still_works.subm | 0 .../tests/fixtures/tostring_field_override.subm | 0 .../fixtures/tostring_field_override_with_capture.subm | 0 .../tests/fixtures/trailing_commas.subm | 0 .../tests/fixtures/truthiness/always_truthy.ts | 0 .../tests/fixtures/truthiness/and_value.ts | 0 .../tests/fixtures/truthiness/bigint_cond.ts | 0 .../tests/fixtures/truthiness/boolean_or_null.ts | 0 .../tests/fixtures/truthiness/false_branch_keeps_type.ts | 0 .../tests/fixtures/truthiness/logical_in_condition.ts | 0 .../tests/fixtures/truthiness/number_cond.ts | 0 .../tests/fixtures/truthiness/or_default.ts | 0 .../tests/fixtures/truthiness/string_cond.ts | 0 .../tests/fixtures/truthiness/string_or_null_empty.ts | 0 .../tests/fixtures/truthiness_rules_out_to_never.ts | 0 .../tests/fixtures/ts_single.ts | 0 .../tests/fixtures/tuple_as_array.subm | 0 .../tests/fixtures/tuple_as_iterable_source.ts | 0 .../tests/fixtures/tuple_basic.subm | 0 .../tests/fixtures/tuple_in_array.subm | 0 .../tests/fixtures/tuple_json_stringify.subm | 0 .../tests/fixtures/tuple_labels.ts | 0 .../tests/fixtures/tuple_length.subm | 0 .../tests/fixtures/tuple_methods.subm | 0 .../tests/fixtures/tuple_nested.subm | 0 .../tests/fixtures/tuple_union_index_access.subm | 0 .../tuples/expect_error_optional_to_required_undefined.ts | 0 .../tests/fixtures/tuples/issue_988_arity.ts | 0 .../tests/fixtures/tuples/issue_988_correlation.ts | 0 .../tests/fixtures/tuples/issue_988_union_context.ts | 0 .../tests/fixtures/tuples/optional_elements.ts | 0 .../fixtures/tuples/required_undefined_to_optional.ts | 0 .../tests/fixtures/type-aliases/alias_null_in_union.subm | 0 .../fixtures/type-aliases/alias_string_host_call.subm | 0 .../fixtures/type-aliases/alias_tuple_literal_return.ts | 0 .../tests/fixtures/type-aliases/alias_union_dedup.ts | 0 .../type-aliases/aliased_function_type_const.subm | 0 .../tests/fixtures/type-aliases/aliased_void_return.ts | 0 .../tests/fixtures/type-aliases/aliased_void_value.ts | 0 .../expect_error_generic_alias_arity_missing.subm | 0 .../expect_error_generic_alias_arity_too_many.subm | 0 .../type-aliases/expect_error_type_alias_duplicate.subm | 0 .../expect_error_type_alias_generic_args.subm | 0 .../type-aliases/expect_error_type_alias_mismatch.subm | 0 .../expect_error_type_alias_unknown_body.subm | 0 .../expect_warning_non_nullable_recursive_alias.ts | 0 .../tests/fixtures/type-aliases/generic_alias_box.subm | 0 .../type-aliases/generic_alias_in_function_signature.subm | 0 .../tests/fixtures/type-aliases/generic_alias_nested.subm | 0 .../tests/fixtures/type-aliases/generic_alias_pair.subm | 0 .../mutually_recursive_alias_cross_package/app/main.ts | 0 .../mutually_recursive_alias_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../type-aliases/mutually_recursive_alias_nullability.ts | 0 .../fixtures/type-aliases/non_generic_alias_nested.subm | 0 .../tests/fixtures/type-aliases/type_alias_array.subm | 0 .../type-aliases/type_alias_discriminated_union.subm | 0 .../tests/fixtures/type-aliases/type_alias_object.subm | 0 .../tests/fixtures/type-aliases/type_alias_primitive.subm | 0 .../tests/fixtures/type-aliases/type_alias_union.subm | 0 .../tests/fixtures/type_guard_rendering_names_the_loss.ts | 0 .../tests/fixtures/type_member_line_breaks.ts | 0 .../tests/fixtures/type_members_named_like_keywords.ts | 0 .../tests/fixtures/type_size_near_limit.ts | 0 .../tests/fixtures/typeof_alone.subm | 0 .../tests/fixtures/typeof_enum_member.ts | 0 .../tests/fixtures/typeof_function_narrows_union.ts | 0 .../tests/fixtures/typeof_type_query.ts | 0 .../tests/fixtures/typeof_undefined_type_query.ts | 0 .../fixtures/types/expect_error_any_not_supported.ts | 0 .../types/expect_error_bare_function_type_params.ts | 0 .../types/expect_error_function_type_param_typo.ts | 0 .../fixtures/types/expect_error_unclosed_grouped_type.ts | 0 .../tests/fixtures/types/parenthesized_type.ts | 0 .../tests/fixtures/uint8array_alloc.subm | 0 .../tests/fixtures/uint8array_at.subm | 0 .../tests/fixtures/uint8array_base64.subm | 0 .../tests/fixtures/uint8array_base64_options.subm | 0 .../tests/fixtures/uint8array_byte_length.subm | 0 .../tests/fixtures/uint8array_copy_within.subm | 0 .../tests/fixtures/uint8array_equals.subm | 0 .../tests/fixtures/uint8array_fill.subm | 0 .../tests/fixtures/uint8array_filter.subm | 0 .../tests/fixtures/uint8array_find.subm | 0 .../tests/fixtures/uint8array_for_each.subm | 0 .../tests/fixtures/uint8array_from_array.subm | 0 .../tests/fixtures/uint8array_from_bytes.subm | 0 .../tests/fixtures/uint8array_from_hex_errors.subm | 0 .../tests/fixtures/uint8array_hex.subm | 0 .../tests/fixtures/uint8array_host_vtable.ts | 0 .../tests/fixtures/uint8array_index_bounds.ts | 0 .../tests/fixtures/uint8array_index_of.subm | 0 .../tests/fixtures/uint8array_indexed_write.subm | 0 .../tests/fixtures/uint8array_join.subm | 0 .../tests/fixtures/uint8array_map.subm | 0 .../tests/fixtures/uint8array_new.subm | 0 .../tests/fixtures/uint8array_new_length.ts | 0 .../tests/fixtures/uint8array_of.subm | 0 .../tests/fixtures/uint8array_ranged_mutations.ts | 0 .../tests/fixtures/uint8array_reduce.subm | 0 .../tests/fixtures/uint8array_reverse.subm | 0 .../tests/fixtures/uint8array_set.subm | 0 .../tests/fixtures/uint8array_set_out_of_range.subm | 0 .../tests/fixtures/uint8array_slice.subm | 0 .../tests/fixtures/uint8array_some_every.subm | 0 .../tests/fixtures/uint8array_sort.subm | 0 .../tests/fixtures/uint8array_subarray.subm | 0 .../tests/fixtures/uint8array_to_json.subm | 0 .../tests/fixtures/uint8array_to_reversed.subm | 0 .../tests/fixtures/uint8array_to_sorted.subm | 0 .../tests/fixtures/uint8array_to_string.subm | 0 .../tests/fixtures/uint8array_truncate.subm | 0 .../tests/fixtures/uint8array_with.subm | 0 .../tests/fixtures/uint8array_wraps_like_to_uint8.ts | 0 .../tests/fixtures/unary_plus_string.ts | 0 .../tests/fixtures/undefined/defaults.ts | 0 .../tests/fixtures/undefined/expect_error_required.ts | 0 .../fixtures/undefined/expect_error_required_argument.ts | 0 .../tests/fixtures/undefined/methods.ts | 0 .../tests/fixtures/undefined/primitives.ts | 0 .../tests/fixtures/undefined/properties.ts | 0 .../tests/fixtures/undefined_array_literal_elements.ts | 0 .../fixtures/undefined_array_literal_nullish_lead.ts | 0 .../tests/fixtures/undefined_base_constructor_order.ts | 0 .../undefined_binding_keeps_synthetic_undefined.ts | 0 .../tests/fixtures/undefined_class_method_alias.ts | 0 .../tests/fixtures/undefined_class_to_json_alias.ts | 0 .../tests/fixtures/undefined_closure_returns.ts | 0 .../tests/fixtures/undefined_collections.ts | 0 .../fixtures/undefined_default_parameter_write_type.ts | 0 .../tests/fixtures/undefined_destructuring_defaults.ts | 0 .../fixtures/undefined_function_optional_compatibility.ts | 0 .../tests/fixtures/undefined_generic_union_inference.ts | 0 .../fixtures/undefined_inferred_parameter_defaults.ts | 0 .../tests/fixtures/undefined_json.ts | 0 .../undefined_later_destructured_parameter_capture.ts | 0 .../tests/fixtures/undefined_later_inferred_default.ts | 0 .../undefined_narrowing/default_parameter_truthiness.ts | 0 .../expect_error_chain_null_guard_keeps_missing.ts | 0 .../expect_error_effectful_undefined_guard.ts | 0 .../expect_error_null_guard_keeps_undefined.ts | 0 .../expect_error_optional_discriminant_unequal.ts | 0 .../expect_error_presence_keeps_undefined.ts | 0 .../expect_error_switch_optional_discriminant_missing.ts | 0 .../expect_error_switch_optional_field_missing.ts | 0 .../expect_error_undefined_guard_keeps_null.ts | 0 .../expect_error_void_member_is_not_narrowed_away.ts | 0 .../tests/fixtures/undefined_narrowing/guards.ts | 0 .../fixtures/undefined_narrowing/nullish_discriminants.ts | 0 .../tests/fixtures/undefined_narrowing/optional_chain.ts | 0 .../optional_discriminant_shared_undefined.ts | 0 .../undefined_narrowing/optional_discriminant_unequal.ts | 0 .../optional_literal_field_beside_tag.ts | 0 .../optional_literal_field_interfaces.ts | 0 .../fixtures/undefined_narrowing/singleton_comparisons.ts | 0 .../switch_null_case_leaves_undefined.ts | 0 .../tuple_discriminant_undefined_position.ts | 0 .../tests/fixtures/undefined_narrowing/typeof_void.ts | 0 .../tests/fixtures/undefined_native_optional_methods.ts | 0 .../tests/fixtures/undefined_optional_method_body.ts | 0 .../fixtures/undefined_optional_method_implements.ts | 0 .../fixtures/undefined_parameter_default_source_types.ts | 0 .../tests/fixtures/undefined_parameter_default_tdz.ts | 0 .../tests/fixtures/undefined_parameter_defaults.ts | 0 .../fixtures/undefined_parameter_destructuring_order.ts | 0 .../tests/fixtures/undefined_parameter_pattern_capture.ts | 0 .../fixtures/undefined_parameter_pattern_literal_types.ts | 0 .../tests/fixtures/undefined_parameter_pattern_write.ts | 0 .../undefined_parameter_property_declared_type.ts | 0 .../undefined_parameter_property_inferred_type.ts | 0 .../tests/fixtures/undefined_parameter_tdz.ts | 0 .../tests/fixtures/undefined_return_completion.ts | 0 .../tests/fixtures/undefined_runtime.ts | 0 .../tests/fixtures/undefined_strings.ts | 0 .../tests/fixtures/undefined_temporal.ts | 0 .../tests/fixtures/undefined_tuple_spread.ts | 0 .../tests/fixtures/undefined_tuple_union.ts | 0 .../tests/fixtures/unicode_whitespace_and_slash_escape.ts | 0 .../tests/fixtures/union_cross_type_eq.subm | 0 .../fixtures/union_field_write_named_fix_round_trip.ts | 0 .../tests/fixtures/union_field_write_names_the_fix.ts | 0 .../fixtures/union_field_write_names_the_narrowing.ts | 0 .../fixtures/union_field_write_non_union_receiver.ts | 0 .../fixtures/union_field_write_unnarrowable_receiver.ts | 0 .../tests/fixtures/union_literal_known_fields.ts | 0 .../tests/fixtures/union_member_lowering_nullability.ts | 0 .../tests/fixtures/union_primitive_eq.subm | 0 .../tests/fixtures/unknown/array_isarray.subm | 0 .../tests/fixtures/unknown/array_isarray_null.subm | 0 .../fixtures/unknown/array_isarray_null_runtime.subm | 0 .../tests/fixtures/unknown/closure_returns_null.subm | 0 .../unknown/contextual_closure_returns_unknown.ts | 0 .../tests/fixtures/unknown/eq_literal.ts | 0 .../tests/fixtures/unknown/eq_null.subm | 0 .../tests/fixtures/unknown/expect_error_and_or.subm | 0 .../tests/fixtures/unknown/expect_error_arithmetic.subm | 0 .../fixtures/unknown/expect_error_body_never_returns.ts | 0 .../tests/fixtures/unknown/expect_error_call.subm | 0 .../tests/fixtures/unknown/expect_error_field_access.subm | 0 .../tests/fixtures/unknown/expect_error_index_access.subm | 0 .../expect_error_non_null_assertion_stays_unknown.ts | 0 .../tests/fixtures/unknown/expect_error_ordering.subm | 0 .../tests/fixtures/unknown/expect_error_truthiness.subm | 0 .../tests/fixtures/unknown/generic_null_arg.subm | 0 .../fixtures/unknown/no_value_cross_package/app/main.ts | 0 .../fixtures/unknown/no_value_cross_package/lib/lib.ts | 0 .../unknown/no_value_cross_package/packages.manifest | 0 .../tests/fixtures/unknown/no_value_returns_null.ts | 0 .../tests/fixtures/unknown/null_into_unknown.subm | 0 .../tests/fixtures/unknown/parameter_round_trip.subm | 0 .../tests/fixtures/unknown/short_circuit.subm | 0 .../tests/fixtures/unknown/tostring.subm | 0 .../tests/fixtures/unknown/typeof_narrowing.subm | 0 .../tests/fixtures/unknown_array_null_element.ts | 0 .../tests/fixtures/uri_encode_decode.subm | 0 .../tests/fixtures/uri_error_builtin.ts | 0 .../tests/fixtures/url/build_basic.subm | 0 .../tests/fixtures/url/build_host_only.ts | 0 .../tests/fixtures/url/encode_decode_component.subm | 0 .../tests/fixtures/url/encode_decode_query.subm | 0 .../tests/fixtures/url/field_narrowing_guard.ts | 0 .../tests/fixtures/url/parse_basic.subm | 0 .../tests/fixtures/url/parse_empty_query.subm | 0 .../tests/fixtures/url/parse_host_trailing_dot.ts | 0 .../tests/fixtures/url/parse_invalid_type_error.ts | 0 .../tests/fixtures/url/parse_no_fragment.subm | 0 .../tests/fixtures/url/parse_no_port.subm | 0 .../tests/fixtures/url/parse_query_encoded.subm | 0 .../tests/fixtures/url/parse_query_multiple.subm | 0 .../tests/fixtures/url/query_type_alias.subm | 0 .../tests/fixtures/void_accessor_nested_value.ts | 0 .../tests/fixtures/void_array_element_generic_value.ts | 0 .../tests/fixtures/void_array_element_shorthand_value.ts | 0 .../tests/fixtures/void_as_generic_arg_value.ts | 0 .../tests/fixtures/void_behind_warning_value.ts | 0 .../tests/fixtures/void_class_field_value.ts | 0 .../tests/fixtures/void_class_static_field_value.ts | 0 .../tests/fixtures/void_closure_param_value.ts | 0 .../fixtures/void_conditional_cast_and_json_value.ts | 0 .../fixtures/void_conditional_in_comparisons_value.ts | 0 .../tests/fixtures/void_equality_value.ts | 0 .../tests/fixtures/void_function_param_value.ts | 0 .../fixtures/void_function_type_alias_param_value.ts | 0 .../tests/fixtures/void_function_type_param_value.ts | 0 .../tests/fixtures/void_hint_diverging_closure.ts | 0 .../tests/fixtures/void_inferred_type_argument.ts | 0 .../tests/fixtures/void_interface_method_type_argument.ts | 0 .../tests/fixtures/void_interface_property_value.ts | 0 .../tests/fixtures/void_interface_type_argument.ts | 0 .../tests/fixtures/void_into_value_slot_value.ts | 0 .../tests/fixtures/void_literal_element_value.ts | 0 .../void_nested_argument_does_not_hide_never_error.ts | 0 .../tests/fixtures/void_nullish_left_value.ts | 0 .../tests/fixtures/void_object_field_type_value.ts | 0 .../fixtures/void_recursive_interface_type_argument.ts | 0 .../fixtures/void_recursive_permutation_type_argument.ts | 0 .../tests/fixtures/void_return_position.ts | 0 .../tests/fixtures/void_return_type_argument.ts | 0 .../tests/fixtures/void_setter_param_value.ts | 0 .../tests/fixtures/void_switch_discriminant_value.ts | 0 .../tests/fixtures/void_tuple_element_value.ts | 0 .../tests/fixtures/void_union_condition.ts | 0 .../tests/fixtures/void_union_member_value.ts | 0 .../tests/fixtures/void_value_annotations.ts | 0 .../tests/fixtures/weak_type_shared_field.ts | 0 .../{interpreter => submilli-engine}/tests/git_memory.rs | 0 .../{interpreter => submilli-engine}/tests/host_memory.rs | 0 .../{interpreter => submilli-engine}/tests/http_live.rs | 0 .../tests/http_live_fixtures/download_basic.subm | 0 .../http_live_fixtures/download_gzip_decompress.subm | 0 .../tests/http_live_fixtures/get_200_body.subm | 0 .../tests/http_live_fixtures/get_404.subm | 0 .../tests/http_live_fixtures/headers_authorization.subm | 0 .../headers_missing_auth_returns_404.subm | 0 .../tests/http_live_fixtures/json_body.subm | 0 .../tests/http_live_fixtures/json_method.subm | 0 .../tests/http_live_fixtures/post_array_body.subm | 0 .../tests/http_live_fixtures/post_null_body.subm | 0 .../tests/http_live_fixtures/post_object_body.subm | 0 .../http_live_fixtures/post_object_body_custom_ct.subm | 0 .../tests/http_live_fixtures/post_string_body.subm | 0 .../tests/http_live_fixtures/post_uint8array_body.subm | 0 .../tests/http_live_fixtures/post_undefined_body.ts | 0 .../http_live_fixtures/put_string_body_ct_override.subm | 0 .../tests/http_live_fixtures/request_runtime_verb.subm | 0 .../tests/http_live_fixtures/response_to_string.subm | 0 .../tests/http_live_fixtures/verb_matrix.subm | 0 .../tests/http_tls_fixtures/ca.pem | 0 .../tests/http_tls_fixtures/localhost-key.pem | 0 .../tests/http_tls_fixtures/localhost.pem | 0 .../tests/lexer_limits.rs | 0 .../{interpreter => submilli-engine}/tests/memory_caps.rs | 0 .../tests/namespace_limits.rs | 0 .../tests/object_vtable_dispatch.rs | 0 .../tests/package_diagnostic_snapshots.rs | 0 .../tests/parser_depth.rs | 0 .../tests/record_limits.rs | 0 ...hots__b1_call_non_callable_lifts_number_interface.snap | 2 +- .../diagnostic_snapshots__b1_dynamic_object_index.snap | 2 +- ...iagnostic_snapshots__b1_field_not_found_on_object.snap | 2 +- .../diagnostic_snapshots__b1_index_into_non_array.snap | 2 +- ...hots__b2_call_arity_mismatch_lifts_anon_signature.snap | 2 +- ...ction_arg_unify_mismatch_lifts_signature_and_diff.snap | 2 +- ...eric_method_type_arg_arity_lifts_method_signature.snap | 2 +- ...tic_snapshots__b2_intrinsic_arity_lifts_signature.snap | 2 +- ...__b2_method_arity_mismatch_lifts_method_signature.snap | 2 +- ..._b2_number_coercion_type_mismatch_lifts_signature.snap | 2 +- ...snapshots__b3_unknown_type_suggests_close_builtin.snap | 2 +- ...lved_identifier_no_suggestion_when_no_close_match.snap | 2 +- ...ts__b3_unresolved_identifier_suggests_close_local.snap | 2 +- ...apshots__b4_cannot_infer_type_param_function_help.snap | 2 +- ...stic_snapshots__b4_const_missing_initializer_help.snap | 2 +- ...agnostic_snapshots__b4_const_reassign_global_help.snap | 2 +- ...iagnostic_snapshots__b4_const_reassign_local_help.snap | 2 +- .../diagnostic_snapshots__b4_function_reassign_help.snap | 2 +- ...nostic_snapshots__b4_let_missing_initializer_help.snap | 2 +- .../diagnostic_snapshots__b4_missing_main_help.snap | 2 +- ...diagnostic_snapshots__b4_missing_return_type_help.snap | 2 +- ...ostic_snapshots__b4_param_missing_annotation_help.snap | 2 +- ...nostic_snapshots__b4_return_outside_function_help.snap | 2 +- .../diagnostic_snapshots__b4_unknown_escape_help.snap | 2 +- ..._snapshots__b5_close_match_reported_at_each_field.snap | 2 +- ...pshots__b5_fresh_object_literal_excess_field_help.snap | 2 +- ...iagnostic_snapshots__b5_function_type_assign_diff.snap | 2 +- ...nostic_snapshots__b5_object_boundary_diff_in_call.snap | 2 +- ...shots__b5_object_field_assign_value_mismatch_diff.snap | 2 +- .../diagnostic_snapshots__doc_duplicate_param_warns.snap | 2 +- .../diagnostic_snapshots__doc_missing_returns_warns.snap | 2 +- ...agnostic_snapshots__doc_param_name_mismatch_warns.snap | 2 +- ...agnostic_snapshots__doc_property_with_param_warns.snap | 2 +- .../diagnostic_snapshots__doc_returns_on_void_warns.snap | 2 +- ...nostic_snapshots__doc_surfaces_in_call_arity_lift.snap | 2 +- .../diagnostic_snapshots__doc_unknown_tag_warns.snap | 2 +- .../diagnostic_snapshots__multi_catch_duplicate_arm.snap | 2 +- ...diagnostic_snapshots__multi_catch_unreachable_arm.snap | 2 +- ...agnostic_snapshots__null_tostring_offers_fix_trio.snap | 2 +- ...napshots__prelude_doc_surfaces_in_array_push_lift.snap | 2 +- ...snapshots__caller_value_passed_on_after_the_check.snap | 2 +- ...__check_in_a_function_the_package_does_not_export.snap | 2 +- ...ic_snapshots__property_read_again_after_the_check.snap | 2 +- .../tests/substitution_limits.rs | 0 .../tests/traps_in_callbacks.rs | 0 .../{interpreter => submilli-engine}/tests/type_limits.rs | 0 .../tests/vfs_containment.rs | 0 crates/submilli-policy/Cargo.toml | 4 ++-- crates/submilli-server/Cargo.toml | 2 +- crates/submilli-shared/Cargo.toml | 2 +- crates/submilli/Cargo.toml | 2 +- examples/docker/conformance.ts | 2 +- 3178 files changed, 157 insertions(+), 157 deletions(-) delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap delete mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap rename crates/{interpreter => submilli-engine}/Cargo.toml (100%) rename crates/{interpreter => submilli-engine}/README.md (100%) rename crates/{interpreter => submilli-engine}/build.rs (100%) rename crates/{interpreter => submilli-engine}/src/arena.rs (100%) rename crates/{interpreter => submilli-engine}/src/artifact_f64.rs (100%) rename crates/{interpreter => submilli-engine}/src/asi.rs (100%) rename crates/{interpreter => submilli-engine}/src/ast.rs (100%) rename crates/{interpreter => submilli-engine}/src/authority.rs (100%) rename crates/{interpreter => submilli-engine}/src/backtrace.rs (100%) rename crates/{interpreter => submilli-engine}/src/capability_derivation.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/analysis.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/argument_defaults.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/bigint_pool.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/bounds.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/box_types.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/call_arguments.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/cast_check.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/cast_diagnostics.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/classes.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/closure_coercions.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/closures.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/dependency_usage.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/dwarf.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/field_guards.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/field_lookup.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/field_name_strings.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/field_names.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_adapters.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/binding_cells.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/cast.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/expr.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/finally.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/json.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/mcp.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/function_emitter/stmt.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/imported_classes.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/init_guard.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/intrinsics.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/invariant_tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/nullish.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/recursive_validators.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/runtime_descriptors.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/runtime_values.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/runtime_values/declarations.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/runtime_values/flow.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/runtime_values/rewrite.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap (78%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap (95%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap (89%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap (92%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap (93%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap (93%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap (94%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap (80%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap (88%) rename crates/{interpreter => submilli-engine}/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap (92%) rename crates/{interpreter => submilli-engine}/src/codegen/string_pool.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/symbol_table.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/this_binding.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/throw.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/user_subtypes.rs (100%) rename crates/{interpreter => submilli-engine}/src/codegen/vtable_walk.rs (100%) rename crates/{interpreter => submilli-engine}/src/compile.rs (100%) rename crates/{interpreter => submilli-engine}/src/compile_capabilities.rs (100%) rename crates/{interpreter => submilli-engine}/src/compiler_error.rs (100%) rename crates/{interpreter => submilli-engine}/src/compiler_limits.rs (100%) rename crates/{interpreter => submilli-engine}/src/diagnostics.rs (100%) rename crates/{interpreter => submilli-engine}/src/did_you_mean.rs (100%) rename crates/{interpreter => submilli-engine}/src/doc_comment.rs (100%) rename crates/{interpreter => submilli-engine}/src/lexer.rs (100%) rename crates/{interpreter => submilli-engine}/src/lib.rs (100%) rename crates/{interpreter => submilli-engine}/src/literal_units.rs (100%) rename crates/{interpreter => submilli-engine}/src/lower_patterns.rs (100%) rename crates/{interpreter => submilli-engine}/src/mangle.rs (100%) rename crates/{interpreter => submilli-engine}/src/package_declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/packages.rs (100%) rename crates/{interpreter => submilli-engine}/src/parser.rs (100%) rename crates/{interpreter => submilli-engine}/src/rendering.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/agents.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/array_storage.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/blocking.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/call_log.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/decision.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/disk_quota.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/embedding.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/exec.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/fs.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/fs/removal.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/fuel.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/gc_singleton.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/host.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/intrinsic_types.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/json.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/json/format.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/json_text.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/limits.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/llm.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/mcp.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/mcp/response.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/metrics.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/number.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/arguments.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/array/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/array/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/array/sort.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/bigint/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/bigint/ops.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/bitwise.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/boolean/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/closure.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/collection.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/console.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/error.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/iterator/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/keep.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/ledger.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/map/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/map/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/math.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/member.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/number/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/object/dynamic.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/object/index.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/object/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/object/static_value.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/regex/engine.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/regex/input.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/regex/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/regex/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/regex/output.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/set/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/set/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/string/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/string/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/string/search.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/string/transforms.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/duration/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/duration/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/instant/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/instant/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/now/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/now/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_date/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_date/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_date_time/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_date_time/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_month_day/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_month_day/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_time/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_time/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_year_month/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/plain_year_month/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/shared.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/zoned_date_time/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/zoned_date_time/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/textcodec/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/textcodec/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/uint8array/install.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/uint8array/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/undefined.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/uri.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/value.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/vtable.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/prelude/vtable/serialization.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/secrets.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/security.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/session_kv.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/skills.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/token_ledger.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/vfs.rs (100%) rename crates/{interpreter => submilli-engine}/src/runtime/watchdog.rs (100%) rename crates/{interpreter => submilli-engine}/src/shape.rs (100%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap (95%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap (73%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap (73%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap (87%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap (81%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap (77%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap (82%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap (77%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap (82%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap (82%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap (73%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap (69%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap (74%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap (74%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap (96%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap (98%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap (99%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap (88%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap (98%) rename crates/{interpreter => submilli-engine}/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap (99%) rename crates/{interpreter => submilli-engine}/src/source.rs (100%) rename crates/{interpreter => submilli-engine}/src/source_validation.rs (100%) rename crates/{interpreter => submilli-engine}/src/span.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/abi.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/agents/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/agents/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/capabilities.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/budget.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/myers.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/patch.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/text.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/code/walk.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/crypto.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/dot_segments.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/embedding/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/embedding/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/fs/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/fs/handles.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/fs/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/class.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/diff.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/history.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/index_limits.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/integration_tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/location.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/lock.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/log_cache.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/metadata_scan.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/meter.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/object.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/operations.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/pack_index_check.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/pack_limits.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/stage.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/storage.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/transport.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/work.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/git/worker.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/policy.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/redirect_guard.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/transport.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/transport_policy.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/transport_policy_tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/http/transport_tls_tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/llm/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/llm/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/optional_tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/secrets.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/security.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/session/cursor.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/session/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/session/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/session/value.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/shared.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/skills/declaration.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/skills/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/test.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/url.rs (100%) rename crates/{interpreter => submilli-engine}/src/stdlib/uuid.rs (100%) rename crates/{interpreter => submilli-engine}/src/token.rs (100%) rename crates/{interpreter => submilli-engine}/src/tree_height.rs (100%) rename crates/{interpreter => submilli-engine}/src/type_info.rs (100%) rename crates/{interpreter => submilli-engine}/src/type_rendering.rs (100%) rename crates/{interpreter => submilli-engine}/src/type_size.rs (100%) rename crates/{interpreter => submilli-engine}/src/type_walk.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/capture.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/desugar/do_while.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/desugar/for_loop.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/desugar/for_of.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/desugar/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/desugar/postfix_incdec.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/aliased_conditions.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/assign_expr.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/assignable.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/best_common_type.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/binding_analysis.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/classes.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/closure_arity.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/comparable.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/comparison_operand.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/diagnostics.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/enums.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/exports.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/expr.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/format_definition.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/format_signature.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/forward_globals.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/generic.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/generic_scopes.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/globals.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/iife.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/import_graph.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/imports.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/inference_sources.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/literal_freshness.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/lookup.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/module_symbols.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/namespace_symbol.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/narrow_scopes.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/narrowing.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/nested_functions.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/object_normalization.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/param_defaults.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/predicate_envs.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/records.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/reserved.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/resolve_type.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/scopes.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/shapes.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/signatures.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap (99%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap (60%) create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap (53%) create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap (53%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap (70%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap (52%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap (52%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap (67%) create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap rename crates/{interpreter => submilli-engine}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap (59%) create mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap rename crates/{interpreter => submilli-engine}/src/typechecker/infer/stmt.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/switch_stmt.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/test_support.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/type_aliases.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/type_diff.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/type_namespace.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/type_predicate.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/type_registry.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/value_operand.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/infer/variance.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/json_schema.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/json_strategy.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/body_walk.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/capability_consistency.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_calls.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/bodies.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/checked.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/findings.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/flow.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/origin.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/package.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/scope.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/stability.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/check_discipline/tests.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/control_flow.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/declarations.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/definite_assignment.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/doc_consistency.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/exported_docs.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/exported_signature_types.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/fallthrough.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/main_required.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/missing_return.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/mod.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/return_outside_function.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/super_call.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/rules/unreachable.rs (100%) rename crates/{interpreter => submilli-engine}/src/typechecker/type_param_substitution.rs (100%) rename crates/{interpreter => submilli-engine}/src/typed_ast.rs (100%) rename crates/{interpreter => submilli-engine}/src/types.rs (100%) rename crates/{interpreter => submilli-engine}/tests/checked_arena.rs (100%) rename crates/{interpreter => submilli-engine}/tests/checked_rendering.rs (100%) rename crates/{interpreter => submilli-engine}/tests/checked_source.rs (100%) rename crates/{interpreter => submilli-engine}/tests/checked_typed_phases.rs (100%) rename crates/{interpreter => submilli-engine}/tests/checked_untyped_phases.rs (100%) rename crates/{interpreter => submilli-engine}/tests/class_rec_group.rs (100%) rename crates/{interpreter => submilli-engine}/tests/closure_arity.rs (100%) rename crates/{interpreter => submilli-engine}/tests/closure_arity_diagnostics.rs (100%) rename crates/{interpreter => submilli-engine}/tests/closure_lowering_errors.rs (100%) rename crates/{interpreter => submilli-engine}/tests/compiler_structure_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/console_failure.rs (100%) rename crates/{interpreter => submilli-engine}/tests/cross_module_gc_types.rs (100%) rename crates/{interpreter => submilli-engine}/tests/decision_records.rs (100%) rename crates/{interpreter => submilli-engine}/tests/determinism.rs (100%) rename crates/{interpreter => submilli-engine}/tests/diagnostic_snapshots.rs (100%) rename crates/{interpreter => submilli-engine}/tests/field_lookup_size.rs (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures.rs (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/alias_index_read_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/alias_peel_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/angle_bracket_cast.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_at.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_callback_truthiness.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_concat.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_copy_within.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_every.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_fill.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_filter.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_filter_guard_narrows_to_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_filter_type_guard_narrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_find.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_findindex.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_flat.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_flat_depth_budget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_flat_depth_error.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_flatmap.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_for_each.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_from.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_from_array_like_length.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_from_array_like_wider_source.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_from_collections.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_generic_spelling.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_host_port_edges.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_includes.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_index_domain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_index_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_index_oob_throws.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_indexed_write_rhs_grows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_iter_next_result.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_join.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_join_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_keeps_regular_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_keys_values_entries.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_last_index_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_length.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_like_union_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_like_union_writes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_best_common_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_element_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_normalized_to_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_object_normalization.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_object_normalization_fresh_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_union_of_arrays.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_union_of_arrays_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_wider_element.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_literal_wider_element_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_map.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_of_object_literal_arrays_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_pop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_push.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_reduce.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_reduce_right.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_reverse.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_shift_unshift.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_slice.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_some.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_sort.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_sort_cached_units.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_sort_keeps_comparator_pushes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_sort_stable_merge.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_splice.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_spread_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_to_reversed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_to_sorted.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_to_spliced.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_values_host_iter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/array_with.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/arrow_return_type_forms.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_allman_braces.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_clause_and_arrow_wraps.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_keyword_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_line_break_after_as_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_line_wrapped_operators.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_statement_ends_at_closing_brace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_template_substitution_wraps.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/asi_type_members_in_brackets.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/assert_pass.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/assert_throws_catchable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/assignment_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/assignment_keeps_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/assignment_narrows_to_declared_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bare_return_in_inferred_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_arithmetic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_compare.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_container_equality.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_conversions.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_decimal_budget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_float_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_join.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_large_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_literal_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_literal_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_namespace_typo.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_number_exact.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_plus_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_to_json.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bigint_to_string_radix.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bind_void_call_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/calls.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/capture_block_shadow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/captured_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/early_assignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/early_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/for_of_pattern_shadow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/for_of_pattern_tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/for_of_tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/hygiene.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/hygiene_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/hygiene_iterator.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/intrinsic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/mutators.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/parseint_required_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/pattern_hygiene.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare_catch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare_let.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare_param.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare_pattern.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/redeclare_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/self_initialization.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/shadowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/binding_scope/tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/asi.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/assignments.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/bigints.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/coercion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/evaluation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/generics.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/invalid.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/invalid_unary.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/live_values.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bitwise/numbers.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/boolean_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/boxed_primitive_vtables.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/braceless_bodies_accepted.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/braceless_control_bodies.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/builtin_error.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/bulk_string_and_byte_copies.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/call_sig_number_from_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/call_sig_string_coercion.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/call_sig_user_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/captured_let_same_frame_reassign.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cast_and_spread_object_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cast_rest_function_to_fixed_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cast_self_nominal_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cast_to_union_member_overlap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cast_void_adapter_to_value_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_array_element_check.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_chain_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_enum_target.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_interface_non_object_throws.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_nested_and_optional.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_number_passthrough.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_object_literal_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_proven_upcast_no_check.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_recursive_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_recursive_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_string_passthrough.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_union_to_member.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_unknown_to_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/as_unknown_to_object_shape.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/expect_error_incompatible_static_cast.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/issue_905_paths.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/issue_982_disjoint.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/issue_982_literal_overlap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/uint8array_is_as.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/chain_generic_method_reference.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/chain_non_generic_optional_calls.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_destructure/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_destructured_param/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_for_of/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_package_value/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_primitives/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_response_mapping/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/clean_unguarded/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_argument/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_array_literal/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_callback/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_captured/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_context/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_merged/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_method_call/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_mutation/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_operand/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_returned/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_spread/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_stored/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/escape_thrown/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_closure/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_internal_module/internal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_internal_module/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_members/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_module_level/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_private_helper/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_reexport/internal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_reexport/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_iteration/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_alias/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_control/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_loop/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/class_chain_at_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/class_never_field_collection_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/class_to_string_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/class_used_before_declaration_throws.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/abstract_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_cross_package/geo/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_different_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_half_inherited.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_implements_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_override.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_redeclared_compatibly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_via_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/accessor_write_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/bad_override.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/captured_class_binding_boxed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/cast_accessor_conformance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/catch_generic_error_bare.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/closure_captures_this.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/closure_in_member_bodies.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/compound_assign_generic_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/construct_and_read_fields.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_default_and_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/dynamic_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_cross_package/labeled/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_cross_package/points/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_nullable_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_sibling_same_shape.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_structural_fields.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_subclass_vs_base.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/equals_vs_other_runtime_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_catch_closure_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_field_mutation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_throw_catch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_typed_catch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_subclass_typed_catch_finally.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/error_union_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_accessor_half_guards.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_missing_static.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_static_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_static_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_assign_to_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_bare_class_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_catch_generic_args.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_catch_non_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_catch_unrelated_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_compound_assign_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_field_redeclared_wider.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_field_used_before_initialization.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_implements_aliased_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_implements_missing_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_implements_wrong_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_implements_wrong_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_instance_on_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_instanceof_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_instanceof_unrelated.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_member_closures_and_switches.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_member_missing_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_member_unreachable_code.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_optional_vs_required_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_override_fewer_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_postfix_static_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_postfix_static_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_read_write_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_class_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_constructor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_field_no_init.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_instance_name_collision.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_on_instance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_on_instance_help.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_optional_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_this.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_subclass_shape_dump.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_to_string_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_type_beats_mutability.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_uninitialized_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/expect_error_unknown_static.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_module/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_module/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_module/zoo/animal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_module/zoo/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package/animals/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package/dogs/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package_private/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cross_package_private/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_cycle.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/extends_non_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_init_inherited.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_initializers.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_all_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_constructor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_enums.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_erased_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_generic_box.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_generic_context.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_host_info.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_narrowing_guard_union_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_in_subclass.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_without_initializer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_aliased_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_empty_subclass.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_generic_base.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_partial_override.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implements_via_later_declared_parent.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/implicit_ctor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_module/animals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_module/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_error_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_negative.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_sibling_same_shape.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_host_built.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_uint8array_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/instanceof_unknown_lhs.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927_argument_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927_cycle.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927_fixed_cycle.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_927_union_cycle.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_967_checked_return_abi.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_967_default_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_967_required.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_967_structural_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_967_wrong_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_973_shorthand_boundary.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_987_inline_object.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_987_private.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_987_setter_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/issue_987_weak_target.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/json_inherited_private/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/json_inherited_private/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/json_inherited_private/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/json_public_properties.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/map_set_class_keys.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/method_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/method_rewritten_through_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/multi_catch_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/multi_catch_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/object_literal_in_member_bodies.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/overridden_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/param_properties.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/permission_denied_error_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/postfix_field_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/private_constructor_packages/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/private_constructor_packages/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/private_cross_module/animal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/private_cross_module/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/protected_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/quota_exceeded_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/range_error_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/range_error_host_throws.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/readonly_write_outside_ctor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/setter_assignment_as_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_and_instance_same_name.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_classref_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_cross_package/mathx/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_generic_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_inheritance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_instance_name_collision.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_members_do_not_redeclare.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_method_as_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_method_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_assign.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_inherited_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_postfix.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_mutable_private.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_private.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_readonly_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/super_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/super_ctor_field_init.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/super_method_override.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/syntax_error_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/this_in_field_initializer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/this_outside_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/type_error_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/type_error_host_thrown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/typed_catch_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/typed_catch_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/undefined_reference_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/universal_to_json.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/universal_to_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_captures_class_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_coercion_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_coercion_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_coercion_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_counter.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_nullable_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_reads_later_module_variable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_accessor_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_after_substitution.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_from_class_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_from_local_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_from_uncalled_signatures.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_sig_shape_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_that_only_throws_is_never.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closure_variable_passed_to_hof.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/callbacks_declare_fewer_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/function_arity_edges.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/function_this.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/iife.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/named_function_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/nested_function_contexts.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/closures/nested_function_declarations.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/code/linear_diff.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/code/workspace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_iterators_live.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_keys_same_value_zero.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/array_from_mapping.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/array_from_nullable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/array_postfix_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/expect_error_spread_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/expect_error_spread_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/expect_error_spread_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/optional_index.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/optional_index_bounds.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/spread_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/tuple_boxing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/tuple_spread.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/uint8_postfix.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_regressions/uint8_postfix_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/collection_to_string_tag.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/comparable_methods_and_self_references.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_basic_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_bigint.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_const_error.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_for_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_index.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_pow_precedence.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_type_error_mixed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/compound_type_error_string_sub.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assign/receiver_evaluated_once.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_assignment_through_never_getter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/compound_write_widens_literal_target.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conditional_object_literal_normalization.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_bigint.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_boolean.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_map_set.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_math.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_regexp.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_temporal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conformance_uint8array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/console_log_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/console_log_variadic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/const_keeps_literals_through_operators.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/const_literal_survives_through_ternaries.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/const_literal_survives_where_immutable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/const_literal_widens_where_mutable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/constant_expression_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/constant_key_reads_as_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/all_five_as_names.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/from_binding_template.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/type_only_import_inline.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/contextual-keywords/type_only_import_statement.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/conversion_field_rest_and_this.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/crypto/hmac_sha256.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/crypto/random_bytes.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/crypto/sha256.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/crypto/sha512.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/crypto/timing_safe_equal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/cyclic_graph_host_walk.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/date_lowercase_variable_works.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/decode_uri_lone_surrogates.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_arrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_before_required.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_boxed_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_enum_variant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_global_const.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/default_param_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/array_hole.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/array_literal_as_tuple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/array_positional.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/array_rest.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/arrow_param_expr_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/class_member_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_array_literal_arity.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_for_of_arity.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/expect_error_rest_not_last.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/for_initializer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/for_of_map.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/for_of_tuple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/function_param.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/let_pattern_mutation.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/nested_in_block.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/object_rename.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/object_rest.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/object_shorthand.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/parameter_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/pattern_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring/single_eval_rhs.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/destructuring_initializer_flow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/getter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/spread_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/spread_tuple.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/tuple.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/diagnostic_counts/unhinted_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/discriminated_union_object_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_callable_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_comments/capability_context_fields.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/duplicate_parameter_names.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_bounds.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_budget_per_run.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_error_taxonomy.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_input_too_long.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_models.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_models_filtered.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_no_provider.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_purpose_invalid.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/embedding_unknown_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/emitter_fallible_healthy.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/emitter_state_healthy.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/empty_array_cast.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/empty_array_cast_non_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/empty_array_never.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enum_member_cases_match_their_own_enum.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enum_member_comparison_narrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enum_member_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enum_negative_zero_initializer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/enum_decl_numeric_typechecks.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/enum_decl_string_typechecks.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/enum_runtime_numeric.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/enum_runtime_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/expect_error_enum_as_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/expect_error_enum_string_missing_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/enums/expect_error_enum_unknown_variant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/equality_comparable_operands.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/equality_literal_operands.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/error_constructor_default_message.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/error_is_error.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/error_is_error_nominal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/error_subclass_object_keys.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/error_subclass_to_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/call_sig_duplicate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/call_sig_not_callable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/default_param_in_fn_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/default_param_type_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/issue_918_partial_catalog.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/new_no_constructor.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/new_no_parens.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/postfix_inc_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/postfix_inc_const.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/errors/postfix_inc_non_numeric.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/break_outside_finally_scope.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/catch_binding_reassign.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/catch_bindingless.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/catch_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/catch_untyped_binds_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/deep_finally_transfers.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/error_default_name.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_bare_throw.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_bare_try.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_catch_any_binding.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/expect_error_throw_non_error.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_caught_path.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_normal_path.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_preserves_pending_completion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_runs_on_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_runs_on_continue.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_runs_on_return.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_transfer_runs_once.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/finally_with_own_return_wins.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_first_match.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/nested_finally_on_return.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/nested_try.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/nested_try_finally_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/return_in_finally_continues_outward.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/throw_caught.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exceptions/throw_in_function_caught_outside.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_annotated_callback_conflict.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_annotated_destructuring_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_annotated_for_of_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_from_array_like_element_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_from_array_like_without_callback.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_from_interface_array_like.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_from_keyed_array_like.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_array_type_after_line_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_arrow_body_and_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_assignment_expression_to_const.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_assignment_reported_once.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_braceless_declaration_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_braceless_declarations.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_break_in_nested_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_callback_param_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_callback_return_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_callback_too_many_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_callback_untyped_extra_param.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_cast_union_without_member_overlap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_class_chain_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_class_in_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_comparable_function_properties.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_comparison_never_true.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_compound_write_reads_base_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_condition_write_after_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_const_literal_operators_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_const_literal_union_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_date_constructor.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_date_now.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_date_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_default_parameter_before_required_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_default_parameter_iife_tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_default_parameter_invalid_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_defaulted_before_required_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_delete_unsupported.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_destructuring_flow_reset.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_destructuring_source_flow_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_do_while_condition_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_duplicate_type_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_empty_array_evolving.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_enum_member_type_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_equality_no_overlap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_error_new_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exponentiation_asserted.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exponentiation_not.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exponentiation_plus.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exponentiation_typeof.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_exponentiation_unary.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_field_does_not_exist.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_arg_contravariant.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_arg_supertype.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_argument_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_method_argument_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_type_argument_variance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_generic_type_size_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_getter_needs_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_getter_without_return_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_if_empty_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_inferred_literal_unknown_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_inferred_literal_weak_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_inferred_type_depth_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_initializer_captured_mutation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_initializer_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_initializer_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_interface_to_string_property.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_interface_to_string_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_const_assigned.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_namespace_read_directly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_variable_inferred_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_later_module_variable_read_directly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_leading_zero_decimal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_legacy_octal_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_literal_type_number_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_literal_type_string_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loop_condition_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_both_sides.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_constant_results.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_parenthesized.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_loose_nullish_void.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_lt_on_boolean.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_map_for_each_param_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_name_after_decimal_point.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nan_comparison.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_duplicate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_missing_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_outer_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_reads_local_below.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_reassigned.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_shadows_param.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_this.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_used_before_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_used_through_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nested_function_write_before_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_nullish_mixed_logical.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_number_plus_string_help.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_numeric_separator.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_object_literal_dictionary_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_object_rest_const_assign.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_object_type_construct_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_chain_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_chain_missing_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_chain_on_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_chain_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_method_body_direct_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_method_super_direct_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_null_field_into_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_optional_parameter_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_parameter_modifier_line_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_parameterless_index_signature.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_cast_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_constructor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_line_break_class_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_line_break_type_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_readonly_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_backreference.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_duplicate_flag.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_invalid_flag.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_invalid_pattern.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_lookahead.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_lookbehind.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_named_backref.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_negative_lookahead.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_negative_lookbehind.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_regex_unterminated.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_required_parameter_after_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_arity_too_few.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_no_annotation.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_non_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_not_last.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_rest_with_default.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_runtime_check_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_runtime_check_locals_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_fallback_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_field_mismatches_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_optional_into_required.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_overwrites_union_tag.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_spread_union_may_be_empty.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_strict_mode_reserved_binding.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_string_at_unnarrowed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_string_or_array_union_method_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_string_plus_number_help.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_string_unknown_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_super_conditional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_super_in_function_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_super_in_nested_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_super_misplaced.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_super_reads_before_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_clause_redeclares_const.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_clause_redeclares_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_syntax_nesting_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_template_nesting_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_this_in_unbound_function_expression.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tostring_wrong_signature.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tostring_wrong_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_arity_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_element_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_empty_rejected.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_index_non_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_index_oob.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_mutators.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_optional_rest_elements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_push.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_tuple_sort.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_args_after_line_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_nesting_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_type_size_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_typeof_invalid_tag.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_typeof_of_a_type_name.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_typeof_unknown_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_unary_minus_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_unary_plus_nullable_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_unclosed_interface_before_export.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_undefined_tuple_spread_required.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_union_literal_assignment_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_union_literal_unknown_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_visibility_after_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_void_compared_with_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_void_condition.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_void_conditional_into_value_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_error_weak_type_no_common_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/exponentiation_grouping.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/field_assignment_flow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/for_of_string_or_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/absence_probing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/append_text.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/bytes_iteration.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/bytes_write_read.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/copy_creates_destination_parents.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/cwd.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/exists_size.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/info_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/linear_remove_move.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/lines_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/lines_iteration.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/list_deep.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/list_entry_shape.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/list_flat.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/list_recursive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/many_handles_recovered.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/max_read_size.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/mkdir_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/move_copy_remove.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/peek_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/peek_crlf.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/read_bytes_range.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/remove_recursive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/root_is_not_a_target.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/stat_kinds.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/text_write_read.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/writer_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/fs/writer_bytes.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_as_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_identity_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_identity_cross_package/lib/extra.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_identity_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_identity_cross_package/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_identity_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_type_rendering_round_trip.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_type_renders_parseable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/function_typed_array_elements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generic_arg_accepts_subclass.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generic_call_infers_common_supertype.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generic_call_infers_from_expected_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generic_type_argument_variance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/array_push_aliased_function.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/array_sort_aliased_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/call_void_return_type_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/callback_parameter_wider_than_element.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/captured_typevar_union_boxed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_box_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_closure_typed_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package/boxes/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_chain/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_chain/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_interface/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_interface/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_namespace/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_cross_package_namespace/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_erased_slot_abi.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_error_subclass.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_extends_concrete_args.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_generic_extends_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_generic_field_rw.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_implements_generic_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_infer_void_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_instanceof.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_instanceof_subclass.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_object_literal_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_recursive_node.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_statics_optional_readonly.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_this_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_two_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_type_arg_shapes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_union_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_universal_slots.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/class_void_type_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_arithmetic_on_t.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_arity_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_arg_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_extends_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_generic_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_instanceof_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_instanceof_args.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_method_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_never_type_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_class_static_type_param.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_conflicting_bindings.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_cross_gp_assignment.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_first_class_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_inference_argument_priority.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_interface_arity.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_method_never_type_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/expect_error_union_member_closely_matched.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/explicit_type_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/first.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_keeps_literal_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_nested_literal_arguments.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_call_widens_fresh_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_calls_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_interface_annotation.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_object_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_recursion.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_union_parameter_naked_priority.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/generic_variance_measured_once.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/identity.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/map_set_aliased_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/nullish_candidates_infer_their_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/object_literal_for_generic_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/recursion.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/returns_generic_closure.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/tostring_on_t.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/tuple_return_generic_fn.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/uninferred_type_param_is_unknown.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/generics/unknown_runtime_descriptor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/global_array_object_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/higher_order_function.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/higher_order_no_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/higher_order_with_capture.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/host_error_catchable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/host_held_values_survive_collection.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/host_owned_vtables.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/host_string_struct_spike.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_get_too_many_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_get_with_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_response_unknown_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http/errors/expect_error_response_unknown_property.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/http_dot_segments.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/alias_named_from.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/embedding_aliased.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/embedding_named.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/embedding_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/embedding_wildcard_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/combined_default_named.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/duplicate_local.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/export_default.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/export_inside_function_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/export_list.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/import_in_function.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/namespace_as_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/namespace_member_as_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/relative_import_escapes_root.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/relative_import_single_file.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/unknown_named.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/unknown_namespace_member.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/unknown_package.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/errors/uuid_not_auto_imported.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/export_modifier_ignored.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/http_namespace_optional_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/import_prelude_namespace_forgiven.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_aliased.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_named.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_package_caller/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_package_caller/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_package_caller/triage/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/llm_wildcard_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_chain/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_chain/inner/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_chain/outer/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_chain/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_closure_callback/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_closure_callback/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/security_check_namespace.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_aliased.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_named.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_package_caller/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_package_caller/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_package_caller/store/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/session_wildcard_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/uuid_aliased.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/uuid_named.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/uuid_namespace.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/uuid_v7.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/imports/uuid_wildcard_namespace.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/inferred_closure_return_widening.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/inferred_literal_extra_fields.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/infinity_nan_parameter_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/inherited_method_lift_substitutes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/initializer_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/initializer_union_shapes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interface_to_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interface_value_capture.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interface_value_into_nullable_object_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interface_value_into_object_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expansive_recursive_assign.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_bad_member_separator.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/interface_property_no_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/single_line_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/structural_object_interface_assign.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/user_interface_decl_typechecks.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/user_interface_factory.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/user_interface_nested_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/user_interface_property_read.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/interfaces/user_interface_value_method_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/is_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/is_primitive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_1147_array_capacity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_1147_push_compatibility.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_821/functions.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_821/optional_functions.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_821/top_level_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_831/cycles.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_831/mixed_cycles.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_836/number_format.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_844/null_algebra.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_844/null_keys.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_872/array_discriminant.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_872/array_guard_boundaries.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_899/expect_error_distinct_enums.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_899/primitive_enum.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_965/global_call_reassignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_966/insert_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_966/inserted_fields_json.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_966/insertion_during_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_966/insertion_preserves_guards.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_968/conditional_loop_writes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_968/nested_loop_writes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_970/accessor_enumeration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/compound_literal_operands.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/conditional_literal_results.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/disjunction_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/enum_literal_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/finally_break_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/finite_alias_depth.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/literal_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/literal_equality_aliases.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/logical_interpolation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/nullable_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/object_spread.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/object_spread_integration.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/object_spread_overrides.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/object_spread_presence.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/polymorphic_covariance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/signed_literal_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/switch_try_termination.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/issue_regressions/void_callback.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/close_called_on_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/close_called_on_exhaustion.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/close_called_on_throw.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterable_hand_rolled.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterator_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterator_continue.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterator_hand_rolled.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/iterator_nullable_t.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/no_close_no_crash.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/iterators/user_interface_iterable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_bare_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_let_json_parse.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_parse_function_target.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_parse_too_many_type_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_parse_type_args_and_as.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_parse_uint8array_target.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_partial_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_stringify_replacer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_stringify_type_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_to_json_wrong_signature.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_to_json_wrong_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/expect_error_unknown_json_member.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/interface_optional_omitted.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/main_array_return.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/main_object_return.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_numbers.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_objects.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_strings.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_tuples.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_array_of_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_as_cast.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_bool.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_diagnostic_preview_path.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_explicit_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_field_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_inferred_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_into_generic_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_into_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_into_interface_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_into_recursive_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_invalid_throws.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_mismatch_throws.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_number_literal_target.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_equals_hash.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_lenient.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_literal_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_nullable_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_optional_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_object_simple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_recursive_discriminated.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_recursive_linked_list.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_recursive_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_recursive_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_string_literal_target.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_t_or_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_tuple_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_tuple_in_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_tuple_literal_position.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_tuple_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_tuple_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_literal_set.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_mixed_tags.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_primitive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_shared_tag.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_status_code.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_tagged.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/parse_union_untagged.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_as_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_bool.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_interface_array_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_interface_optional_field_assigned.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_negative_zero.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_null_valued_nullable_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_nullable_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_nullable_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_nullable_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_object_optional_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_pretty_eval_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_pretty_space_number.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_pretty_space_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/stringify_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/to_json_direct.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/to_json_field_override.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/to_json_field_override_with_capture.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json/to_json_via_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_parse_lone_surrogate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_stringify_collection.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_stringify_erased_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_stringify_reassigned_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_stringify_width_subtype.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/json_utf16_lossless.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/later_module_variable_shadows_namespace.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/let_keeps_regular_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/linear_regex_output.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/linear_string_transforms.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_keeping_operators.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_own_type_keeps_binding_writable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_own_type_under_annotation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_type_capture.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_type_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_type_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_type_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/literal_union_interface_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_batch_ordering.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_batch_partial_failure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_budget_aggregate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_budget_per_execution.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_budget_release_after_trap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_call_erased.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_call_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_error_taxonomy.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_models_all_callable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_models_empty.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_models_filtered.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_models_no_description.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_no_provider.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_prompt_bounds.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_schema_argument_rejected.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_schema_unsupported.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_typed_get.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_typed_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/llm_typed_provider_ignored_schema.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loop_condition_write_narrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loop_empty_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/do_while_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/do_while_continue.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/do_while_once.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/do_while_truthiness_cond.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_continue.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_empty_slots.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_let_per_iteration_binding.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_break.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_continue.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_empty.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_number_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_string_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_of_tuple.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/loops/for_truthiness_cond.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/map_for_each.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/map_from_differing_tuple_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/map_set_from_iterable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/map_set_identity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/basic_string_keys.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/cached_hashes_and_ledger.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/ctor_from_entries.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_for_of_non_iterable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_record_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_weakmap_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_weakmap_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_weakset_type.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/expect_error_weakset_value.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/host_port_roundtrip.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order_after_resize.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order_delete_middle.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order_set.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order_set_after_resize.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/insertion_order_set_delete_middle.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/iterate_for_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/iterate_iterator_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/iterate_set_iterator_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/iterator_concurrent.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/iterator_sees_later_sets.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/keys_values_entries_iterators.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/number_keys.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/object_keys.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/object_values_get_field_access.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/phase2_typecheck.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/phase6_for_of_typecheck.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/postfix_chain_on_new.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/resize.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/set_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/set_ctor_from_values.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/set_host_port_roundtrip.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/set_iterate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/set_keys_values_entries_iterators.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/tombstone_reclamation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/maps/tombstone_reuse.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_constants.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_hypot.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_pi.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_random.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/math_transcendentals.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/method_call_through_string_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/method_lift_substitutes_receiver_args.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/module_let_narrowing_reads_live_after_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/module_variable_before_initialization.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/aliased_enum_import/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/aliased_enum_import/m_enum.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/default_param_cross_module/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/default_param_cross_module/util.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/cycle/b.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/cycle/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/main_decl/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/missing_module/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/private_symbol/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/errors/private_symbol/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_direct_documented/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_direct_missing/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_interface_member/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_internal_helper/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_reexport_missing/util.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_sibling_only/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_docs_sibling_only/util.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_function_type_surface/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/exported_function_type_surface/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/namespace_import/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/namespace_import/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/reexport_basic/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/reexport_basic/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/reserved_word_export_names/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/reserved_word_export_names/values.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/sibling_import/lib.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/sibling_import/util.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/ts_mixed/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/ts_mixed/wrap.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/type_only_reexport/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/type_only_reexport/util.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/union_write_help_unimported_member/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/multi/union_write_help_unimported_member/widget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/mvp_greet.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/namespace_shadowed_by_top_level.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nan_local_binding_not_flagged.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowed_boxed_binding_read.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/aliased_conditions_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/array_isarray_narrows.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/array_isarray_on_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assign_narrowing_survives_join.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assign_narrows_block_tail.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assign_sibling_invalidates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assign_then_call_invalidates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/assignment_value_truthiness.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/call_rereads_field_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/captured_mutator_write_back.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/chained_short_circuit.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/class_field_and_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/class_field_nested_if.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/class_private_field_same_module.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/closure_last_assignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/closure_reguards_field_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/computed_write_retains_literal_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_top_level.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/const_narrow_survives_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/discriminant_kind_equality.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/discriminant_kind_inequality.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/discriminant_member_sets.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/discriminant_three_variants.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/dropped_index_path_hint.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/enum_discriminant_case.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/equality_between_unions.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_continue_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_field_do.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_field_for.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_field_forof.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_field_while.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_finally_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_local_direct.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_local_nested.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_local_switch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_local_try.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_update.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_getter_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_getter_path_cast.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_getter_path_index.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/field_path_two_deep_structural.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_clause_joins.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_condition_preserved.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_do_break.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_for_condition_preserved.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_join_820.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_join_898.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_join_901.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_join_902.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_loops.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_numeric_source.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_switch_unmatched.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/flow_this_for.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/function_union_assignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/generic_class_box_of_box.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/global_field_paths.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/global_guard_mutation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/global_ternary_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/guard_through_an_element.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/immediately_invoked_functions.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/in_operator_basic_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/in_operator_dynamic_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/in_operator_union_filter.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/in_operator_unknown_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/in_typeof_field_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/index_by_constant_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/index_path_and_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/interface_field_holding_class.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_785_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_785_switch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_786.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_816.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_889.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_890_anonymous_lift.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_890_predicate_lift.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_929.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_929_expect_error_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948_composed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948_discriminant.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948_nested.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948_switch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/issue_948_union_refined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/join_points_keep_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/literal_index_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_assignment_result.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_big_bom.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_big_separator.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_boolean_literal_result.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_call_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_function_reference.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_index_conversion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_index_noncanonical.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_json_arguments.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_map_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_builtin_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_class_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_fresh_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_function_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_member_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_number_predicate.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_optional_shape_analysis.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_array_argument/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_array_argument/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_function_reference/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_function_reference/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_imported_global/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_imported_global/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_object_argument/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_object_argument/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_postfix_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_pow_boundary.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_pow_nan.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_generic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_includes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_length.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_receiver_to_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_regex_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_runtime_values.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_search_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_string_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_valueof_conversion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_values_packages/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_values_packages/library/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/live_values_packages/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/loop_exit_body_local_join.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/loop_join_after_continue.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/loop_tail_narrowings.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/loop_wrapped_body_forms.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/nested_block_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/nested_shadow_reuse.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/never_array_hints_later_elements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/never_field_in_object_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/never_operand_in_dead_code.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/never_read_in_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/nominal_union_field_access.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/non_null_assertion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/not_truthiness_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/null_comparison_guards.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/null_eq_else.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/null_global_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/null_neq_then.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/null_neq_unbox.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/nullable_rw_target_write_out.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/nullable_smoke.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/operator_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/postfix_narrowed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_chained_post_if.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_discriminant_post_if.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_eq_else.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_neq_then.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/property_path_neq_then_post_if.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/reassign_same_type_rewidens.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/return_in_if_carries_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/rules_out_every_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/short_circuit_and_narrows.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/short_circuit_or_narrows.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/sibling_paths_three_idents.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/switch_boolean_discriminant.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/switch_without_default_falls_through.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/ternary_and_interface_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/this_rooted_paths.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/truthiness_field_path_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/truthiness_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_aliased_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_boolean_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_field_path_else_branch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_field_path_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_function_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_function_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_number_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_object_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_object_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_string_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_three_way_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/typeof_through_generic_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_discriminant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_else_branch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_generic_strip_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_in_typeof.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_nullable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_primitive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/user_guard_type_alias.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_body_local_continue_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_body_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_break_carries_narrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_break_two_paths_widens.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_fixed_point_continue.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing/while_fixed_point_converges.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/narrowing_field_path_nested_region.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nested_function_default_param.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nested_function_reads_later_local.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nested_function_top_level_block.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/expect_error_never_falls_through.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/expect_error_return_value_in_never_fn.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/expect_error_value_into_never_slot.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/never_assignable_to_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/never_in_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never/never_return_throw.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never_annotated_closure_in_void_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never_function_void_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never_generic_callback.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/never_operands.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/new_uint8array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/new_with_dotted_form.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/no_panic_prelude_invariants.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/null_discriminant_narrows.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullable_receiver_names_the_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/chained.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/simple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/void_right.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/with_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_coalescing/with_parens_ok.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/nullish_grouping_and_zero_literals.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_global_predicates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_parse_statics.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_predicates_no_coercion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_radix_strings.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_static_constants.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_static_predicates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_to_fixed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_to_precision_exponential.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/number_to_string_radix.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/numeric_separators_and_decimal_point.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_function_typed_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_is.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_key_reassigned_wider_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_literal_dictionary_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_literal_evaluation_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_literal_into_nullable_tagged_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_literal_normalization_at_depth.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_literal_subtype_reduction.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_rest_copies.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_rest_let.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_spread_widened_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_statics.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_statics_host.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/object_type_member_named_new.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_field_assign_missing_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_field_assign_non_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_invalid_assign_target.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_union_missing_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/field_assign_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/field_assign_const_binding.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/field_assign_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/field_assign_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/interface_field_assignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/interface_property_write_dispatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/multiline_object_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/nullable_eq_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/nullable_field_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/optional_field_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/optional_field_null_compare.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/optional_present_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/optional_undefined_presence.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/property_shorthand.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/quoted_property_names.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/reserved_keyword_property_names.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/union_field_access.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/widen_to_nullable_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/width_sub_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/width_sub_assign.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/width_sub_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/width_sub_intermediate_arg.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/objects/width_sub_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chain_near_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chain_non_nullable_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chain_nullable_host_property.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chain_string_key.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/chain_then_coalesce.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/field_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/multiple_optional.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/nested_field_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/non_null_division.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/non_null_void_result.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_call_nullable_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_class_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_class_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_class_field_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_generic_method.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_index.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_index_bounds.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_inherited_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_interface_accessor.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_interface_property.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_method_nullable_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_narrowed_step.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_non_null_continuation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_object_prelude_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_primitive_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_redundant_primitive.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_union_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/optional_void_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_chaining/void_result_bindings.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_field_written_null_serializes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_to_json_property.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/optional_to_string_property.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_narrows_return_with_finally.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_returns_into_narrower_slot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_slot_variance.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_variance_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_variance_cross_package/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_variance_cross_package/child/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/override_variance_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_binding_key/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_dynamic_name/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_extra_tag/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_missing_tag/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_payload_key/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_unknown_field/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_unknown_field/types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/class_member_bodies/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/class_missing_return/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/class_unreachable_code/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/doc_callable_members/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/doc_consistency/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/missing_return/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/switch_fallthrough/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/top_level_return/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/unassigned_class_field/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/package_rules/unreachable_code/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_param_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_param_cross_package/host/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_param_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/const_ref_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/const_ref_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/parameter_literal_union_default_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/parse_int_radix_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_bigint.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_captured.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_global.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/postfix_incdec/inc_dec_index.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/expect_error_in_nullable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/expect_error_optional_write_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/expect_error_write_only_implements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/in_accessors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/in_erased_presence.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/in_presence.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/inherited_accessors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/interface_json_surrogates.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/interface_postfix.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/interface_wide_mutation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/postfix_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/postfix_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/postfix_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/recursive_mutation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/required_undefined_round_trip.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/property_regressions/required_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/radix_number_literals.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/assignment_narrows_to_value_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_array_writes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_non_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/getonly_cannot_implement_writable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/inline_object_runtime.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/interface_property_write_rejected.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/object_type_property_write_rejected.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/readonly_array_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly/writable_property_write_ok.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly_cast_qualifiers.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly_rest_parameter.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly_rest_parameter_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/readonly_string_length.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/indexed_growth_and_equality.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/optional_dynamic_presence.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_accessors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_bad_computed_spread.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_checked_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_class_guards.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_conditional_spread.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_errors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_evaluation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_features.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_forward_index.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_function_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_generic_contract_errors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_generic_method_errors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_generic_methods.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_composition.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_composition_errors.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_conflicts.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_forward_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_members.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_inherit_narrow.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_interface_reads.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_literal_writes.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_postfix_checked.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_recursive.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_recursive_interface_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_structural_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/records/record_unions.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_linked_list.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_through_array.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_through_generic_call.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_tree.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/alias_union_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/recursive-types/interface_resolution.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_exec_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_flags_all.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_input_cache.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_lastindex_non_global.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_lastindex_sticky.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_literal_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_named_captures.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_named_captures_unmatched.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_non_ascii_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_numbered_captures.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_per_site_lastindex.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_property_reads.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_shared_input.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_test_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_test_lastindex_global.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_to_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regex_utf16_offsets.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_invalid_flags_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_match_keeps_lone_surrogates.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_missing_source.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_optional_flags.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_replace_split_match_js.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_shorthand_classes_match_js.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rejected_field_write_rhs_hint.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rest_callback_for_fixed_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rest_param_arrow.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rest_param_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rest_param_generic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/rest_param_mixed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/return_paths_void_union_and_getters.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/secrets_main_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_basic.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_cursor_length_budget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_get_erased.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_get_mismatch.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_get_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_list.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_list_cursor_is_sealed.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_list_filtered.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_remove_denied.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_surrogate_fidelity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_typed_get.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/session_unsupported_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/set_algebra.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/set_iteration_parity.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/set_relations.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/shared_serializer_buffer.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/array_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/array_empty_source.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/array_only_spreads.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/err_array_spread_element_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/err_array_spread_non_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/err_object_spread_interface.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/err_object_spread_non_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/object_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/object_multiple_spreads.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/object_override_literal_after.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread/object_override_literal_before.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread_index_signature_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread_into_discriminated_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread_of_conditional_or_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread_of_falsy_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/spread_union_assigned_back.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/static_binding_as_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/strict_mode_reserved_words_as_properties.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_admitted_builders.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_at_nullable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_case.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_char_at.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_code_point_at_out_of_range.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_concat.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_for_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_from_char_code.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_from_char_code_wraps.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_from_code_point.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_index_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_key_member_access.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_length.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_linear_search.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_literal_lone_surrogates.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_match_all.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_match_and_search.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_multiline_raw_newline.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_normalize.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_of_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_ops_keep_lone_surrogates.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_or_array_union_methods.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_ordering.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_pad.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_repeat.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_repeat_negative.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_replace.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_replace_all.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_slice.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_split.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_starts_with.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_trim.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/string_well_formed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_equals_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_equals_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_equals_cross_package/points/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_equals_shape_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_interfaces.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/structural_visit_budget.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/subclass_super_on_every_path.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_assertNever_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_break_in_case.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_break_post_state.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_default_first.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_discriminated_union_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_enum_discriminant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_enum_exhaustive_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_literal_union_default_narrows.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_literal_union_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_multi_label.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_multi_label_discriminated.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_multi_label_literal_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_no_default.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_number_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_return_in_case.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_string_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch/switch_tuple_union_exhaustive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_case_body_recovery_no_panic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_case_hex_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_expression_label_duplicates.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_expression_labels.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_function_declarations_hoisted.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_null_assignment_in_loop.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_nullable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/switch_signed_number_labels.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/syntax_nesting_near_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_generic_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_boolean.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_interface.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_no_substitution.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_non_null_assert.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_nullish.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_number.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_literal_tuple.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_nesting_near_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/template_substitution_spans.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal/fields_bag_by_interface_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_compare.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_compare_sort.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_arithmetic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_compare_from.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_from_iso.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_host_validation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_like_arg.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_object_literal.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_round_total.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_sign.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_to_string_options.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_with_abs_blank.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_duration_zdt_anchor.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_error_messages.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_errors_are_catchable.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_getters.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_hook_contract.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_arithmetic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_equals.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_from_epoch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_iso_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_instant_round.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_long_duration.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_negative_duration.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_now_plain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_now_smoke.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_now_time_zone_id.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_now_zoned_date_time_iso.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_numeric_range_validation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_options_interface_arg.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plain_arithmetic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plain_erased_boundaries.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plain_to_zoned.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plaindate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plaindate_to_plaindatetime.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plaindatetime.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plainmonthday.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plaintime.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_plainyearmonth.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_to_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_until_options.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_with.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_alias_identity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_dst_spring_forward.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_equals.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_from_iso.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_host_complete.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_to_instant.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_to_plain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zdt_with_time_zone.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/temporal_zoned_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/expect_error_missing_colon.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/logical_branches.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/simple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/truthiness_cond.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/void_branches.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ternary/with_optional_chain.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/text_codec_unicode.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/text_codec_with_base64.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/text_encoder_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/to_json_record_non_string_throws.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/top_level_function_identity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tostring_default_still_works.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tostring_field_override.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tostring_field_override_with_capture.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/trailing_commas.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/always_truthy.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/and_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/bigint_cond.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/boolean_or_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/false_branch_keeps_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/logical_in_condition.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/number_cond.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/or_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/string_cond.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness/string_or_null_empty.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/truthiness_rules_out_to_never.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/ts_single.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_as_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_as_iterable_source.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_in_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_json_stringify.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_labels.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_length.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_methods.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuple_union_index_access.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/issue_988_arity.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/issue_988_correlation.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/issue_988_union_context.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/optional_elements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/tuples/required_undefined_to_optional.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/alias_null_in_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/alias_string_host_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/alias_tuple_literal_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/alias_union_dedup.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/aliased_function_type_const.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/aliased_void_return.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/aliased_void_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/generic_alias_box.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/generic_alias_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/generic_alias_pair.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/non_generic_alias_nested.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/type_alias_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/type_alias_discriminated_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/type_alias_object.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/type_alias_primitive.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type-aliases/type_alias_union.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type_guard_rendering_names_the_loss.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type_member_line_breaks.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type_members_named_like_keywords.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/type_size_near_limit.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/typeof_alone.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/typeof_enum_member.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/typeof_function_narrows_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/typeof_type_query.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/typeof_undefined_type_query.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/types/expect_error_any_not_supported.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/types/expect_error_bare_function_type_params.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/types/expect_error_function_type_param_typo.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/types/expect_error_unclosed_grouped_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/types/parenthesized_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_alloc.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_at.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_base64.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_base64_options.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_byte_length.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_copy_within.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_equals.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_fill.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_filter.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_find.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_for_each.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_from_array.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_from_bytes.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_from_hex_errors.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_hex.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_host_vtable.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_index_bounds.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_index_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_indexed_write.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_join.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_map.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_new.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_new_length.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_of.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_ranged_mutations.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_reduce.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_reverse.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_set.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_set_out_of_range.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_slice.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_some_every.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_sort.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_subarray.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_to_json.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_to_reversed.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_to_sorted.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_to_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_truncate.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_with.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uint8array_wraps_like_to_uint8.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unary_plus_string.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/expect_error_required.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/expect_error_required_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/methods.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/primitives.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined/properties.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_array_literal_elements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_array_literal_nullish_lead.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_base_constructor_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_class_method_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_class_to_json_alias.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_closure_returns.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_collections.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_default_parameter_write_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_destructuring_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_function_optional_compatibility.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_generic_union_inference.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_inferred_parameter_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_json.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_later_destructured_parameter_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_later_inferred_default.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/guards.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/nullish_discriminants.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/optional_chain.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/singleton_comparisons.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_narrowing/typeof_void.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_native_optional_methods.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_optional_method_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_optional_method_implements.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_default_source_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_default_tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_defaults.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_destructuring_order.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_pattern_capture.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_pattern_literal_types.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_pattern_write.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_property_declared_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_property_inferred_type.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_parameter_tdz.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_return_completion.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_runtime.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_strings.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_temporal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_tuple_spread.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/undefined_tuple_union.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unicode_whitespace_and_slash_escape.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_cross_type_eq.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_field_write_named_fix_round_trip.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_field_write_names_the_fix.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_field_write_names_the_narrowing.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_field_write_non_union_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_field_write_unnarrowable_receiver.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_literal_known_fields.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_member_lowering_nullability.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/union_primitive_eq.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/array_isarray.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/array_isarray_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/array_isarray_null_runtime.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/closure_returns_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/contextual_closure_returns_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/eq_literal.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/eq_null.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_and_or.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_arithmetic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_body_never_returns.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_call.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_field_access.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_index_access.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_ordering.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/expect_error_truthiness.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/generic_null_arg.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/no_value_cross_package/app/main.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/no_value_cross_package/packages.manifest (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/no_value_returns_null.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/null_into_unknown.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/parameter_round_trip.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/short_circuit.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/tostring.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown/typeof_narrowing.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/unknown_array_null_element.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uri_encode_decode.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/uri_error_builtin.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/build_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/build_host_only.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/encode_decode_component.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/encode_decode_query.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/field_narrowing_guard.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_empty_query.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_host_trailing_dot.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_invalid_type_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_no_fragment.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_no_port.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_query_encoded.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/parse_query_multiple.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/url/query_type_alias.subm (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_accessor_nested_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_array_element_generic_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_array_element_shorthand_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_as_generic_arg_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_behind_warning_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_class_field_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_class_static_field_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_closure_param_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_conditional_cast_and_json_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_conditional_in_comparisons_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_equality_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_function_param_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_function_type_alias_param_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_function_type_param_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_hint_diverging_closure.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_inferred_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_interface_method_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_interface_property_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_interface_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_into_value_slot_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_literal_element_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_nullish_left_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_object_field_type_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_recursive_interface_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_recursive_permutation_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_return_position.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_return_type_argument.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_setter_param_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_switch_discriminant_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_tuple_element_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_union_condition.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_union_member_value.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/void_value_annotations.ts (100%) rename crates/{interpreter => submilli-engine}/tests/fixtures/weak_type_shared_field.ts (100%) rename crates/{interpreter => submilli-engine}/tests/git_memory.rs (100%) rename crates/{interpreter => submilli-engine}/tests/host_memory.rs (100%) rename crates/{interpreter => submilli-engine}/tests/http_live.rs (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/download_basic.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/download_gzip_decompress.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/get_200_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/get_404.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/headers_authorization.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/headers_missing_auth_returns_404.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/json_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/json_method.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_array_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_null_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_object_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_object_body_custom_ct.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_string_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_uint8array_body.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/post_undefined_body.ts (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/put_string_body_ct_override.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/request_runtime_verb.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/response_to_string.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_live_fixtures/verb_matrix.subm (100%) rename crates/{interpreter => submilli-engine}/tests/http_tls_fixtures/ca.pem (100%) rename crates/{interpreter => submilli-engine}/tests/http_tls_fixtures/localhost-key.pem (100%) rename crates/{interpreter => submilli-engine}/tests/http_tls_fixtures/localhost.pem (100%) rename crates/{interpreter => submilli-engine}/tests/lexer_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/memory_caps.rs (100%) rename crates/{interpreter => submilli-engine}/tests/namespace_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/object_vtable_dispatch.rs (100%) rename crates/{interpreter => submilli-engine}/tests/package_diagnostic_snapshots.rs (100%) rename crates/{interpreter => submilli-engine}/tests/parser_depth.rs (100%) rename crates/{interpreter => submilli-engine}/tests/record_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap (95%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap (86%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap (84%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap (95%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap (78%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap (93%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap (92%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap (90%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap (87%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap (79%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap (79%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap (83%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap (80%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap (78%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap (80%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap (88%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap (86%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap (85%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap (86%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap (74%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap (77%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap (89%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap (82%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap (82%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap (94%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap (94%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap (87%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap (92%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap (78%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap (82%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap (80%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap (88%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap (79%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap (75%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap (84%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap (85%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap (86%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap (89%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap (90%) rename crates/{interpreter => submilli-engine}/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap (87%) rename crates/{interpreter => submilli-engine}/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap (94%) rename crates/{interpreter => submilli-engine}/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap (94%) rename crates/{interpreter => submilli-engine}/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap (95%) rename crates/{interpreter => submilli-engine}/tests/substitution_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/traps_in_callbacks.rs (100%) rename crates/{interpreter => submilli-engine}/tests/type_limits.rs (100%) rename crates/{interpreter => submilli-engine}/tests/vfs_containment.rs (100%) diff --git a/AGENTS.md b/AGENTS.md index 64feda709..a6a1ccf45 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -84,7 +84,7 @@ Compile errors should include source context, a caret, relevant type or function signatures, and an actionable fix. Thread source spans through every compiler phase. When adding or removing a gated capability, update -[the capability catalog](crates/interpreter/src/stdlib/capabilities.rs) in the same +[the capability catalog](crates/submilli-engine/src/stdlib/capabilities.rs) in the same change, including its summary, filter fields, and example filter. Blueprint scaffolding reads this catalog. @@ -154,7 +154,7 @@ violations. Apply these exceptions when following review and no-panic workflows. Fuel bounds the CPU a program spends, wherever it spends it. Wasm instructions burn fuel by themselves. A host function (a standard-library or prelude function implemented in Rust) must charge for its own work from the same budget, through -`crates/interpreter/src/runtime/fuel.rs`. A host function that charges nothing +`crates/submilli-engine/src/runtime/fuel.rs`. A host function that charges nothing is a free loop for any program. **Host work is discounted.** One fuel is about 2.5 ns, the cost of one @@ -297,7 +297,7 @@ final release candidate before publication. Enable the flag during development only for focused verification of changes to these tests or their selection, and for the Git standard-library checks below. -Whenever modifying the Git standard library (`crates/interpreter/src/stdlib/git/`), +Whenever modifying the Git standard library (`crates/submilli-engine/src/stdlib/git/`), run the Git memory-limit tests in addition to other affected checks: ```sh diff --git a/Cargo.toml b/Cargo.toml index 591eb95a1..7167b39c8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ resolver = "3" members = [ "crates/conformance", - "crates/interpreter", + "crates/submilli-engine", "crates/submilli", "crates/submilli-build", "crates/submilli-blueprint", diff --git a/crates/conformance/Cargo.toml b/crates/conformance/Cargo.toml index fa40f8a12..2e5332dc9 100644 --- a/crates/conformance/Cargo.toml +++ b/crates/conformance/Cargo.toml @@ -10,6 +10,6 @@ publish.workspace = true workspace = true [dev-dependencies] -interpreter = { package = "submilli-engine", path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../submilli-engine" } tokio = { workspace = true, features = ["rt"] } wasmtime = { workspace = true } diff --git a/crates/conformance/typescript/README.md b/crates/conformance/typescript/README.md index 595a040a0..7f35c0346 100644 --- a/crates/conformance/typescript/README.md +++ b/crates/conformance/typescript/README.md @@ -419,7 +419,7 @@ from the retained program. These are typechecker comparisons, not runtime tests: declaration placeholders are intentionally not executed. The executable Record regressions live in the -[interpreter fixtures](../../interpreter/tests/fixtures/records/). +[interpreter fixtures](../../submilli-engine/tests/fixtures/records/). The generic dictionary local uses `{}` instead of the usual placeholder cast, because casting to an erased generic parameter is unsupported. Both compilers retain its declared index value type `T`. diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap deleted file mode 100644 index 5ff731148..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -(arg0: number, arg1: string) => boolean diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap deleted file mode 100644 index 8baeb041e..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Box { - label?: string; -} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap deleted file mode 100644 index 3fe4c19c3..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap +++ /dev/null @@ -1,8 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Item { - key: number; - tag: string; -} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap deleted file mode 100644 index 3ae1b85ce..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Cell { - value: number; -} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap deleted file mode 100644 index c3bfa5ebf..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap +++ /dev/null @@ -1,8 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -{ - name: string; - x: number; -} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap deleted file mode 100644 index 3f7428f93..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Number { - toString(): string; -} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap deleted file mode 100644 index 18de567a2..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/type_diff.rs -expression: out.unwrap() ---- -extra field(s): `y` diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap deleted file mode 100644 index 8e602c22f..000000000 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/interpreter/src/typechecker/infer/type_diff.rs -expression: out.unwrap() ---- -missing field(s): `y` diff --git a/crates/submilli-blueprint/src/lib.rs b/crates/submilli-blueprint/src/lib.rs index c66a0cd40..700f3636b 100644 --- a/crates/submilli-blueprint/src/lib.rs +++ b/crates/submilli-blueprint/src/lib.rs @@ -174,10 +174,6 @@ impl Blueprint { self.default_action.is_some() || !self.permissions.is_empty() } - /// Resolve a capability `check()` for `caller` against this blueprint's - /// permission rules. Pure — no parsing happens here (filter ASTs are parsed - /// at registration), so it is cheap to call per check. The fall-through is - /// `default:` when set, else `deny`. /// Resolve a permission and its zero-based index within the caller's rules. /// `None` identifies the blueprint's fall-through default. pub fn resolve_permission_with_rule( @@ -218,6 +214,10 @@ impl Blueprint { ) } + /// Resolve a capability `check()` for `caller` against this blueprint's + /// permission rules. Pure — no parsing happens here (filter ASTs are parsed + /// at registration), so it is cheap to call per check. The fall-through is + /// `default:` when set, else `deny`. pub fn resolve_permission( &self, caller: &str, diff --git a/crates/submilli-build/Cargo.toml b/crates/submilli-build/Cargo.toml index 1d710a416..d2b667f2f 100644 --- a/crates/submilli-build/Cargo.toml +++ b/crates/submilli-build/Cargo.toml @@ -10,7 +10,7 @@ publish.workspace = true workspace = true [dependencies] -interpreter = { package = "submilli-engine", path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../submilli-engine" } submilli-blueprint = { path = "../submilli-blueprint" } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } diff --git a/crates/interpreter/Cargo.toml b/crates/submilli-engine/Cargo.toml similarity index 100% rename from crates/interpreter/Cargo.toml rename to crates/submilli-engine/Cargo.toml diff --git a/crates/interpreter/README.md b/crates/submilli-engine/README.md similarity index 100% rename from crates/interpreter/README.md rename to crates/submilli-engine/README.md diff --git a/crates/interpreter/build.rs b/crates/submilli-engine/build.rs similarity index 100% rename from crates/interpreter/build.rs rename to crates/submilli-engine/build.rs diff --git a/crates/interpreter/src/arena.rs b/crates/submilli-engine/src/arena.rs similarity index 100% rename from crates/interpreter/src/arena.rs rename to crates/submilli-engine/src/arena.rs diff --git a/crates/interpreter/src/artifact_f64.rs b/crates/submilli-engine/src/artifact_f64.rs similarity index 100% rename from crates/interpreter/src/artifact_f64.rs rename to crates/submilli-engine/src/artifact_f64.rs diff --git a/crates/interpreter/src/asi.rs b/crates/submilli-engine/src/asi.rs similarity index 100% rename from crates/interpreter/src/asi.rs rename to crates/submilli-engine/src/asi.rs diff --git a/crates/interpreter/src/ast.rs b/crates/submilli-engine/src/ast.rs similarity index 100% rename from crates/interpreter/src/ast.rs rename to crates/submilli-engine/src/ast.rs diff --git a/crates/interpreter/src/authority.rs b/crates/submilli-engine/src/authority.rs similarity index 100% rename from crates/interpreter/src/authority.rs rename to crates/submilli-engine/src/authority.rs diff --git a/crates/interpreter/src/backtrace.rs b/crates/submilli-engine/src/backtrace.rs similarity index 100% rename from crates/interpreter/src/backtrace.rs rename to crates/submilli-engine/src/backtrace.rs diff --git a/crates/interpreter/src/capability_derivation.rs b/crates/submilli-engine/src/capability_derivation.rs similarity index 100% rename from crates/interpreter/src/capability_derivation.rs rename to crates/submilli-engine/src/capability_derivation.rs diff --git a/crates/interpreter/src/codegen/analysis.rs b/crates/submilli-engine/src/codegen/analysis.rs similarity index 100% rename from crates/interpreter/src/codegen/analysis.rs rename to crates/submilli-engine/src/codegen/analysis.rs diff --git a/crates/interpreter/src/codegen/argument_defaults.rs b/crates/submilli-engine/src/codegen/argument_defaults.rs similarity index 100% rename from crates/interpreter/src/codegen/argument_defaults.rs rename to crates/submilli-engine/src/codegen/argument_defaults.rs diff --git a/crates/interpreter/src/codegen/bigint_pool.rs b/crates/submilli-engine/src/codegen/bigint_pool.rs similarity index 100% rename from crates/interpreter/src/codegen/bigint_pool.rs rename to crates/submilli-engine/src/codegen/bigint_pool.rs diff --git a/crates/interpreter/src/codegen/bounds.rs b/crates/submilli-engine/src/codegen/bounds.rs similarity index 100% rename from crates/interpreter/src/codegen/bounds.rs rename to crates/submilli-engine/src/codegen/bounds.rs diff --git a/crates/interpreter/src/codegen/box_types.rs b/crates/submilli-engine/src/codegen/box_types.rs similarity index 100% rename from crates/interpreter/src/codegen/box_types.rs rename to crates/submilli-engine/src/codegen/box_types.rs diff --git a/crates/interpreter/src/codegen/call_arguments.rs b/crates/submilli-engine/src/codegen/call_arguments.rs similarity index 100% rename from crates/interpreter/src/codegen/call_arguments.rs rename to crates/submilli-engine/src/codegen/call_arguments.rs diff --git a/crates/interpreter/src/codegen/cast_check.rs b/crates/submilli-engine/src/codegen/cast_check.rs similarity index 100% rename from crates/interpreter/src/codegen/cast_check.rs rename to crates/submilli-engine/src/codegen/cast_check.rs diff --git a/crates/interpreter/src/codegen/cast_diagnostics.rs b/crates/submilli-engine/src/codegen/cast_diagnostics.rs similarity index 100% rename from crates/interpreter/src/codegen/cast_diagnostics.rs rename to crates/submilli-engine/src/codegen/cast_diagnostics.rs diff --git a/crates/interpreter/src/codegen/classes.rs b/crates/submilli-engine/src/codegen/classes.rs similarity index 100% rename from crates/interpreter/src/codegen/classes.rs rename to crates/submilli-engine/src/codegen/classes.rs diff --git a/crates/interpreter/src/codegen/closure_coercions.rs b/crates/submilli-engine/src/codegen/closure_coercions.rs similarity index 100% rename from crates/interpreter/src/codegen/closure_coercions.rs rename to crates/submilli-engine/src/codegen/closure_coercions.rs diff --git a/crates/interpreter/src/codegen/closures.rs b/crates/submilli-engine/src/codegen/closures.rs similarity index 100% rename from crates/interpreter/src/codegen/closures.rs rename to crates/submilli-engine/src/codegen/closures.rs diff --git a/crates/interpreter/src/codegen/dependency_usage.rs b/crates/submilli-engine/src/codegen/dependency_usage.rs similarity index 100% rename from crates/interpreter/src/codegen/dependency_usage.rs rename to crates/submilli-engine/src/codegen/dependency_usage.rs diff --git a/crates/interpreter/src/codegen/dwarf.rs b/crates/submilli-engine/src/codegen/dwarf.rs similarity index 100% rename from crates/interpreter/src/codegen/dwarf.rs rename to crates/submilli-engine/src/codegen/dwarf.rs diff --git a/crates/interpreter/src/codegen/field_guards.rs b/crates/submilli-engine/src/codegen/field_guards.rs similarity index 100% rename from crates/interpreter/src/codegen/field_guards.rs rename to crates/submilli-engine/src/codegen/field_guards.rs diff --git a/crates/interpreter/src/codegen/field_lookup.rs b/crates/submilli-engine/src/codegen/field_lookup.rs similarity index 100% rename from crates/interpreter/src/codegen/field_lookup.rs rename to crates/submilli-engine/src/codegen/field_lookup.rs diff --git a/crates/interpreter/src/codegen/field_name_strings.rs b/crates/submilli-engine/src/codegen/field_name_strings.rs similarity index 100% rename from crates/interpreter/src/codegen/field_name_strings.rs rename to crates/submilli-engine/src/codegen/field_name_strings.rs diff --git a/crates/interpreter/src/codegen/field_names.rs b/crates/submilli-engine/src/codegen/field_names.rs similarity index 100% rename from crates/interpreter/src/codegen/field_names.rs rename to crates/submilli-engine/src/codegen/field_names.rs diff --git a/crates/interpreter/src/codegen/function_adapters.rs b/crates/submilli-engine/src/codegen/function_adapters.rs similarity index 100% rename from crates/interpreter/src/codegen/function_adapters.rs rename to crates/submilli-engine/src/codegen/function_adapters.rs diff --git a/crates/interpreter/src/codegen/function_emitter/binding_cells.rs b/crates/submilli-engine/src/codegen/function_emitter/binding_cells.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/binding_cells.rs rename to crates/submilli-engine/src/codegen/function_emitter/binding_cells.rs diff --git a/crates/interpreter/src/codegen/function_emitter/cast.rs b/crates/submilli-engine/src/codegen/function_emitter/cast.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/cast.rs rename to crates/submilli-engine/src/codegen/function_emitter/cast.rs diff --git a/crates/interpreter/src/codegen/function_emitter/expr.rs b/crates/submilli-engine/src/codegen/function_emitter/expr.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/expr.rs rename to crates/submilli-engine/src/codegen/function_emitter/expr.rs diff --git a/crates/interpreter/src/codegen/function_emitter/finally.rs b/crates/submilli-engine/src/codegen/function_emitter/finally.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/finally.rs rename to crates/submilli-engine/src/codegen/function_emitter/finally.rs diff --git a/crates/interpreter/src/codegen/function_emitter/json.rs b/crates/submilli-engine/src/codegen/function_emitter/json.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/json.rs rename to crates/submilli-engine/src/codegen/function_emitter/json.rs diff --git a/crates/interpreter/src/codegen/function_emitter/mcp.rs b/crates/submilli-engine/src/codegen/function_emitter/mcp.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/mcp.rs rename to crates/submilli-engine/src/codegen/function_emitter/mcp.rs diff --git a/crates/interpreter/src/codegen/function_emitter/mod.rs b/crates/submilli-engine/src/codegen/function_emitter/mod.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/mod.rs rename to crates/submilli-engine/src/codegen/function_emitter/mod.rs diff --git a/crates/interpreter/src/codegen/function_emitter/stmt.rs b/crates/submilli-engine/src/codegen/function_emitter/stmt.rs similarity index 100% rename from crates/interpreter/src/codegen/function_emitter/stmt.rs rename to crates/submilli-engine/src/codegen/function_emitter/stmt.rs diff --git a/crates/interpreter/src/codegen/imported_classes.rs b/crates/submilli-engine/src/codegen/imported_classes.rs similarity index 100% rename from crates/interpreter/src/codegen/imported_classes.rs rename to crates/submilli-engine/src/codegen/imported_classes.rs diff --git a/crates/interpreter/src/codegen/init_guard.rs b/crates/submilli-engine/src/codegen/init_guard.rs similarity index 100% rename from crates/interpreter/src/codegen/init_guard.rs rename to crates/submilli-engine/src/codegen/init_guard.rs diff --git a/crates/interpreter/src/codegen/intrinsics.rs b/crates/submilli-engine/src/codegen/intrinsics.rs similarity index 100% rename from crates/interpreter/src/codegen/intrinsics.rs rename to crates/submilli-engine/src/codegen/intrinsics.rs diff --git a/crates/interpreter/src/codegen/invariant_tests.rs b/crates/submilli-engine/src/codegen/invariant_tests.rs similarity index 100% rename from crates/interpreter/src/codegen/invariant_tests.rs rename to crates/submilli-engine/src/codegen/invariant_tests.rs diff --git a/crates/interpreter/src/codegen/mod.rs b/crates/submilli-engine/src/codegen/mod.rs similarity index 100% rename from crates/interpreter/src/codegen/mod.rs rename to crates/submilli-engine/src/codegen/mod.rs diff --git a/crates/interpreter/src/codegen/nullish.rs b/crates/submilli-engine/src/codegen/nullish.rs similarity index 100% rename from crates/interpreter/src/codegen/nullish.rs rename to crates/submilli-engine/src/codegen/nullish.rs diff --git a/crates/interpreter/src/codegen/recursive_validators.rs b/crates/submilli-engine/src/codegen/recursive_validators.rs similarity index 100% rename from crates/interpreter/src/codegen/recursive_validators.rs rename to crates/submilli-engine/src/codegen/recursive_validators.rs diff --git a/crates/interpreter/src/codegen/runtime_descriptors.rs b/crates/submilli-engine/src/codegen/runtime_descriptors.rs similarity index 100% rename from crates/interpreter/src/codegen/runtime_descriptors.rs rename to crates/submilli-engine/src/codegen/runtime_descriptors.rs diff --git a/crates/interpreter/src/codegen/runtime_values.rs b/crates/submilli-engine/src/codegen/runtime_values.rs similarity index 100% rename from crates/interpreter/src/codegen/runtime_values.rs rename to crates/submilli-engine/src/codegen/runtime_values.rs diff --git a/crates/interpreter/src/codegen/runtime_values/declarations.rs b/crates/submilli-engine/src/codegen/runtime_values/declarations.rs similarity index 100% rename from crates/interpreter/src/codegen/runtime_values/declarations.rs rename to crates/submilli-engine/src/codegen/runtime_values/declarations.rs diff --git a/crates/interpreter/src/codegen/runtime_values/flow.rs b/crates/submilli-engine/src/codegen/runtime_values/flow.rs similarity index 100% rename from crates/interpreter/src/codegen/runtime_values/flow.rs rename to crates/submilli-engine/src/codegen/runtime_values/flow.rs diff --git a/crates/interpreter/src/codegen/runtime_values/rewrite.rs b/crates/submilli-engine/src/codegen/runtime_values/rewrite.rs similarity index 100% rename from crates/interpreter/src/codegen/runtime_values/rewrite.rs rename to crates/submilli-engine/src/codegen/runtime_values/rewrite.rs diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap similarity index 78% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap index 126987720..7544d882d 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs expression: dump --- error: Error: oops diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap similarity index 95% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap index 2953cef40..834454d1d 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs assertion_line: 5147 expression: dump --- diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap similarity index 89% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap index 7794d310b..107917427 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap similarity index 92% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap index 4b53f98e6..cf832d626 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs assertion_line: 4927 expression: dump --- diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap similarity index 93% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap index aa162f204..ea01bb546 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs assertion_line: 5058 expression: dump --- diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap similarity index 93% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap index 58b9e35a1..821af9ad2 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs assertion_line: 5043 expression: dump --- diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap similarity index 94% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap index a1a35939b..1d0a318fc 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs assertion_line: 5013 expression: dump --- diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap similarity index 80% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap index 4df265c4b..c56613d30 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs expression: dump --- error: TypeError: type mismatch: expected P, got object at $["a"] diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap similarity index 88% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap index 891bd212f..78d9dc171 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap similarity index 92% rename from crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap rename to crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap index ec458bd24..c7428efbc 100644 --- a/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap +++ b/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/codegen/mod.rs +source: crates/submilli-engine/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/interpreter/src/codegen/string_pool.rs b/crates/submilli-engine/src/codegen/string_pool.rs similarity index 100% rename from crates/interpreter/src/codegen/string_pool.rs rename to crates/submilli-engine/src/codegen/string_pool.rs diff --git a/crates/interpreter/src/codegen/symbol_table.rs b/crates/submilli-engine/src/codegen/symbol_table.rs similarity index 100% rename from crates/interpreter/src/codegen/symbol_table.rs rename to crates/submilli-engine/src/codegen/symbol_table.rs diff --git a/crates/interpreter/src/codegen/this_binding.rs b/crates/submilli-engine/src/codegen/this_binding.rs similarity index 100% rename from crates/interpreter/src/codegen/this_binding.rs rename to crates/submilli-engine/src/codegen/this_binding.rs diff --git a/crates/interpreter/src/codegen/throw.rs b/crates/submilli-engine/src/codegen/throw.rs similarity index 100% rename from crates/interpreter/src/codegen/throw.rs rename to crates/submilli-engine/src/codegen/throw.rs diff --git a/crates/interpreter/src/codegen/user_subtypes.rs b/crates/submilli-engine/src/codegen/user_subtypes.rs similarity index 100% rename from crates/interpreter/src/codegen/user_subtypes.rs rename to crates/submilli-engine/src/codegen/user_subtypes.rs diff --git a/crates/interpreter/src/codegen/vtable_walk.rs b/crates/submilli-engine/src/codegen/vtable_walk.rs similarity index 100% rename from crates/interpreter/src/codegen/vtable_walk.rs rename to crates/submilli-engine/src/codegen/vtable_walk.rs diff --git a/crates/interpreter/src/compile.rs b/crates/submilli-engine/src/compile.rs similarity index 100% rename from crates/interpreter/src/compile.rs rename to crates/submilli-engine/src/compile.rs diff --git a/crates/interpreter/src/compile_capabilities.rs b/crates/submilli-engine/src/compile_capabilities.rs similarity index 100% rename from crates/interpreter/src/compile_capabilities.rs rename to crates/submilli-engine/src/compile_capabilities.rs diff --git a/crates/interpreter/src/compiler_error.rs b/crates/submilli-engine/src/compiler_error.rs similarity index 100% rename from crates/interpreter/src/compiler_error.rs rename to crates/submilli-engine/src/compiler_error.rs diff --git a/crates/interpreter/src/compiler_limits.rs b/crates/submilli-engine/src/compiler_limits.rs similarity index 100% rename from crates/interpreter/src/compiler_limits.rs rename to crates/submilli-engine/src/compiler_limits.rs diff --git a/crates/interpreter/src/diagnostics.rs b/crates/submilli-engine/src/diagnostics.rs similarity index 100% rename from crates/interpreter/src/diagnostics.rs rename to crates/submilli-engine/src/diagnostics.rs diff --git a/crates/interpreter/src/did_you_mean.rs b/crates/submilli-engine/src/did_you_mean.rs similarity index 100% rename from crates/interpreter/src/did_you_mean.rs rename to crates/submilli-engine/src/did_you_mean.rs diff --git a/crates/interpreter/src/doc_comment.rs b/crates/submilli-engine/src/doc_comment.rs similarity index 100% rename from crates/interpreter/src/doc_comment.rs rename to crates/submilli-engine/src/doc_comment.rs diff --git a/crates/interpreter/src/lexer.rs b/crates/submilli-engine/src/lexer.rs similarity index 100% rename from crates/interpreter/src/lexer.rs rename to crates/submilli-engine/src/lexer.rs diff --git a/crates/interpreter/src/lib.rs b/crates/submilli-engine/src/lib.rs similarity index 100% rename from crates/interpreter/src/lib.rs rename to crates/submilli-engine/src/lib.rs diff --git a/crates/interpreter/src/literal_units.rs b/crates/submilli-engine/src/literal_units.rs similarity index 100% rename from crates/interpreter/src/literal_units.rs rename to crates/submilli-engine/src/literal_units.rs diff --git a/crates/interpreter/src/lower_patterns.rs b/crates/submilli-engine/src/lower_patterns.rs similarity index 100% rename from crates/interpreter/src/lower_patterns.rs rename to crates/submilli-engine/src/lower_patterns.rs diff --git a/crates/interpreter/src/mangle.rs b/crates/submilli-engine/src/mangle.rs similarity index 100% rename from crates/interpreter/src/mangle.rs rename to crates/submilli-engine/src/mangle.rs diff --git a/crates/interpreter/src/package_declaration.rs b/crates/submilli-engine/src/package_declaration.rs similarity index 100% rename from crates/interpreter/src/package_declaration.rs rename to crates/submilli-engine/src/package_declaration.rs diff --git a/crates/interpreter/src/packages.rs b/crates/submilli-engine/src/packages.rs similarity index 100% rename from crates/interpreter/src/packages.rs rename to crates/submilli-engine/src/packages.rs diff --git a/crates/interpreter/src/parser.rs b/crates/submilli-engine/src/parser.rs similarity index 100% rename from crates/interpreter/src/parser.rs rename to crates/submilli-engine/src/parser.rs diff --git a/crates/interpreter/src/rendering.rs b/crates/submilli-engine/src/rendering.rs similarity index 100% rename from crates/interpreter/src/rendering.rs rename to crates/submilli-engine/src/rendering.rs diff --git a/crates/interpreter/src/runtime/agents.rs b/crates/submilli-engine/src/runtime/agents.rs similarity index 100% rename from crates/interpreter/src/runtime/agents.rs rename to crates/submilli-engine/src/runtime/agents.rs diff --git a/crates/interpreter/src/runtime/array_storage.rs b/crates/submilli-engine/src/runtime/array_storage.rs similarity index 100% rename from crates/interpreter/src/runtime/array_storage.rs rename to crates/submilli-engine/src/runtime/array_storage.rs diff --git a/crates/interpreter/src/runtime/blocking.rs b/crates/submilli-engine/src/runtime/blocking.rs similarity index 100% rename from crates/interpreter/src/runtime/blocking.rs rename to crates/submilli-engine/src/runtime/blocking.rs diff --git a/crates/interpreter/src/runtime/call_log.rs b/crates/submilli-engine/src/runtime/call_log.rs similarity index 100% rename from crates/interpreter/src/runtime/call_log.rs rename to crates/submilli-engine/src/runtime/call_log.rs diff --git a/crates/interpreter/src/runtime/decision.rs b/crates/submilli-engine/src/runtime/decision.rs similarity index 100% rename from crates/interpreter/src/runtime/decision.rs rename to crates/submilli-engine/src/runtime/decision.rs diff --git a/crates/interpreter/src/runtime/disk_quota.rs b/crates/submilli-engine/src/runtime/disk_quota.rs similarity index 100% rename from crates/interpreter/src/runtime/disk_quota.rs rename to crates/submilli-engine/src/runtime/disk_quota.rs diff --git a/crates/interpreter/src/runtime/embedding.rs b/crates/submilli-engine/src/runtime/embedding.rs similarity index 100% rename from crates/interpreter/src/runtime/embedding.rs rename to crates/submilli-engine/src/runtime/embedding.rs diff --git a/crates/interpreter/src/runtime/exec.rs b/crates/submilli-engine/src/runtime/exec.rs similarity index 100% rename from crates/interpreter/src/runtime/exec.rs rename to crates/submilli-engine/src/runtime/exec.rs diff --git a/crates/interpreter/src/runtime/fs.rs b/crates/submilli-engine/src/runtime/fs.rs similarity index 100% rename from crates/interpreter/src/runtime/fs.rs rename to crates/submilli-engine/src/runtime/fs.rs diff --git a/crates/interpreter/src/runtime/fs/removal.rs b/crates/submilli-engine/src/runtime/fs/removal.rs similarity index 100% rename from crates/interpreter/src/runtime/fs/removal.rs rename to crates/submilli-engine/src/runtime/fs/removal.rs diff --git a/crates/interpreter/src/runtime/fuel.rs b/crates/submilli-engine/src/runtime/fuel.rs similarity index 100% rename from crates/interpreter/src/runtime/fuel.rs rename to crates/submilli-engine/src/runtime/fuel.rs diff --git a/crates/interpreter/src/runtime/gc_singleton.rs b/crates/submilli-engine/src/runtime/gc_singleton.rs similarity index 100% rename from crates/interpreter/src/runtime/gc_singleton.rs rename to crates/submilli-engine/src/runtime/gc_singleton.rs diff --git a/crates/interpreter/src/runtime/host.rs b/crates/submilli-engine/src/runtime/host.rs similarity index 100% rename from crates/interpreter/src/runtime/host.rs rename to crates/submilli-engine/src/runtime/host.rs diff --git a/crates/interpreter/src/runtime/intrinsic_types.rs b/crates/submilli-engine/src/runtime/intrinsic_types.rs similarity index 100% rename from crates/interpreter/src/runtime/intrinsic_types.rs rename to crates/submilli-engine/src/runtime/intrinsic_types.rs diff --git a/crates/interpreter/src/runtime/json.rs b/crates/submilli-engine/src/runtime/json.rs similarity index 100% rename from crates/interpreter/src/runtime/json.rs rename to crates/submilli-engine/src/runtime/json.rs diff --git a/crates/interpreter/src/runtime/json/format.rs b/crates/submilli-engine/src/runtime/json/format.rs similarity index 100% rename from crates/interpreter/src/runtime/json/format.rs rename to crates/submilli-engine/src/runtime/json/format.rs diff --git a/crates/interpreter/src/runtime/json_text.rs b/crates/submilli-engine/src/runtime/json_text.rs similarity index 100% rename from crates/interpreter/src/runtime/json_text.rs rename to crates/submilli-engine/src/runtime/json_text.rs diff --git a/crates/interpreter/src/runtime/limits.rs b/crates/submilli-engine/src/runtime/limits.rs similarity index 100% rename from crates/interpreter/src/runtime/limits.rs rename to crates/submilli-engine/src/runtime/limits.rs diff --git a/crates/interpreter/src/runtime/llm.rs b/crates/submilli-engine/src/runtime/llm.rs similarity index 100% rename from crates/interpreter/src/runtime/llm.rs rename to crates/submilli-engine/src/runtime/llm.rs diff --git a/crates/interpreter/src/runtime/mcp.rs b/crates/submilli-engine/src/runtime/mcp.rs similarity index 100% rename from crates/interpreter/src/runtime/mcp.rs rename to crates/submilli-engine/src/runtime/mcp.rs diff --git a/crates/interpreter/src/runtime/mcp/response.rs b/crates/submilli-engine/src/runtime/mcp/response.rs similarity index 100% rename from crates/interpreter/src/runtime/mcp/response.rs rename to crates/submilli-engine/src/runtime/mcp/response.rs diff --git a/crates/interpreter/src/runtime/metrics.rs b/crates/submilli-engine/src/runtime/metrics.rs similarity index 100% rename from crates/interpreter/src/runtime/metrics.rs rename to crates/submilli-engine/src/runtime/metrics.rs diff --git a/crates/interpreter/src/runtime/mod.rs b/crates/submilli-engine/src/runtime/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/mod.rs rename to crates/submilli-engine/src/runtime/mod.rs diff --git a/crates/interpreter/src/runtime/number.rs b/crates/submilli-engine/src/runtime/number.rs similarity index 100% rename from crates/interpreter/src/runtime/number.rs rename to crates/submilli-engine/src/runtime/number.rs diff --git a/crates/interpreter/src/runtime/prelude/arguments.rs b/crates/submilli-engine/src/runtime/prelude/arguments.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/arguments.rs rename to crates/submilli-engine/src/runtime/prelude/arguments.rs diff --git a/crates/interpreter/src/runtime/prelude/array/install.rs b/crates/submilli-engine/src/runtime/prelude/array/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/array/install.rs rename to crates/submilli-engine/src/runtime/prelude/array/install.rs diff --git a/crates/interpreter/src/runtime/prelude/array/mod.rs b/crates/submilli-engine/src/runtime/prelude/array/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/array/mod.rs rename to crates/submilli-engine/src/runtime/prelude/array/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/array/sort.rs b/crates/submilli-engine/src/runtime/prelude/array/sort.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/array/sort.rs rename to crates/submilli-engine/src/runtime/prelude/array/sort.rs diff --git a/crates/interpreter/src/runtime/prelude/bigint/mod.rs b/crates/submilli-engine/src/runtime/prelude/bigint/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/bigint/mod.rs rename to crates/submilli-engine/src/runtime/prelude/bigint/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/bigint/ops.rs b/crates/submilli-engine/src/runtime/prelude/bigint/ops.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/bigint/ops.rs rename to crates/submilli-engine/src/runtime/prelude/bigint/ops.rs diff --git a/crates/interpreter/src/runtime/prelude/bitwise.rs b/crates/submilli-engine/src/runtime/prelude/bitwise.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/bitwise.rs rename to crates/submilli-engine/src/runtime/prelude/bitwise.rs diff --git a/crates/interpreter/src/runtime/prelude/boolean/mod.rs b/crates/submilli-engine/src/runtime/prelude/boolean/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/boolean/mod.rs rename to crates/submilli-engine/src/runtime/prelude/boolean/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/closure.rs b/crates/submilli-engine/src/runtime/prelude/closure.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/closure.rs rename to crates/submilli-engine/src/runtime/prelude/closure.rs diff --git a/crates/interpreter/src/runtime/prelude/collection.rs b/crates/submilli-engine/src/runtime/prelude/collection.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/collection.rs rename to crates/submilli-engine/src/runtime/prelude/collection.rs diff --git a/crates/interpreter/src/runtime/prelude/console.rs b/crates/submilli-engine/src/runtime/prelude/console.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/console.rs rename to crates/submilli-engine/src/runtime/prelude/console.rs diff --git a/crates/interpreter/src/runtime/prelude/declaration.rs b/crates/submilli-engine/src/runtime/prelude/declaration.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/declaration.rs rename to crates/submilli-engine/src/runtime/prelude/declaration.rs diff --git a/crates/interpreter/src/runtime/prelude/error.rs b/crates/submilli-engine/src/runtime/prelude/error.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/error.rs rename to crates/submilli-engine/src/runtime/prelude/error.rs diff --git a/crates/interpreter/src/runtime/prelude/iterator/mod.rs b/crates/submilli-engine/src/runtime/prelude/iterator/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/iterator/mod.rs rename to crates/submilli-engine/src/runtime/prelude/iterator/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/keep.rs b/crates/submilli-engine/src/runtime/prelude/keep.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/keep.rs rename to crates/submilli-engine/src/runtime/prelude/keep.rs diff --git a/crates/interpreter/src/runtime/prelude/ledger.rs b/crates/submilli-engine/src/runtime/prelude/ledger.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/ledger.rs rename to crates/submilli-engine/src/runtime/prelude/ledger.rs diff --git a/crates/interpreter/src/runtime/prelude/map/install.rs b/crates/submilli-engine/src/runtime/prelude/map/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/map/install.rs rename to crates/submilli-engine/src/runtime/prelude/map/install.rs diff --git a/crates/interpreter/src/runtime/prelude/map/mod.rs b/crates/submilli-engine/src/runtime/prelude/map/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/map/mod.rs rename to crates/submilli-engine/src/runtime/prelude/map/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/math.rs b/crates/submilli-engine/src/runtime/prelude/math.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/math.rs rename to crates/submilli-engine/src/runtime/prelude/math.rs diff --git a/crates/interpreter/src/runtime/prelude/member.rs b/crates/submilli-engine/src/runtime/prelude/member.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/member.rs rename to crates/submilli-engine/src/runtime/prelude/member.rs diff --git a/crates/interpreter/src/runtime/prelude/mod.rs b/crates/submilli-engine/src/runtime/prelude/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/mod.rs rename to crates/submilli-engine/src/runtime/prelude/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/number/mod.rs b/crates/submilli-engine/src/runtime/prelude/number/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/number/mod.rs rename to crates/submilli-engine/src/runtime/prelude/number/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/object/dynamic.rs b/crates/submilli-engine/src/runtime/prelude/object/dynamic.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/object/dynamic.rs rename to crates/submilli-engine/src/runtime/prelude/object/dynamic.rs diff --git a/crates/interpreter/src/runtime/prelude/object/index.rs b/crates/submilli-engine/src/runtime/prelude/object/index.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/object/index.rs rename to crates/submilli-engine/src/runtime/prelude/object/index.rs diff --git a/crates/interpreter/src/runtime/prelude/object/mod.rs b/crates/submilli-engine/src/runtime/prelude/object/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/object/mod.rs rename to crates/submilli-engine/src/runtime/prelude/object/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/object/static_value.rs b/crates/submilli-engine/src/runtime/prelude/object/static_value.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/object/static_value.rs rename to crates/submilli-engine/src/runtime/prelude/object/static_value.rs diff --git a/crates/interpreter/src/runtime/prelude/regex/engine.rs b/crates/submilli-engine/src/runtime/prelude/regex/engine.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/regex/engine.rs rename to crates/submilli-engine/src/runtime/prelude/regex/engine.rs diff --git a/crates/interpreter/src/runtime/prelude/regex/input.rs b/crates/submilli-engine/src/runtime/prelude/regex/input.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/regex/input.rs rename to crates/submilli-engine/src/runtime/prelude/regex/input.rs diff --git a/crates/interpreter/src/runtime/prelude/regex/install.rs b/crates/submilli-engine/src/runtime/prelude/regex/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/regex/install.rs rename to crates/submilli-engine/src/runtime/prelude/regex/install.rs diff --git a/crates/interpreter/src/runtime/prelude/regex/mod.rs b/crates/submilli-engine/src/runtime/prelude/regex/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/regex/mod.rs rename to crates/submilli-engine/src/runtime/prelude/regex/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/regex/output.rs b/crates/submilli-engine/src/runtime/prelude/regex/output.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/regex/output.rs rename to crates/submilli-engine/src/runtime/prelude/regex/output.rs diff --git a/crates/interpreter/src/runtime/prelude/set/install.rs b/crates/submilli-engine/src/runtime/prelude/set/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/set/install.rs rename to crates/submilli-engine/src/runtime/prelude/set/install.rs diff --git a/crates/interpreter/src/runtime/prelude/set/mod.rs b/crates/submilli-engine/src/runtime/prelude/set/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/set/mod.rs rename to crates/submilli-engine/src/runtime/prelude/set/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/string/install.rs b/crates/submilli-engine/src/runtime/prelude/string/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/string/install.rs rename to crates/submilli-engine/src/runtime/prelude/string/install.rs diff --git a/crates/interpreter/src/runtime/prelude/string/mod.rs b/crates/submilli-engine/src/runtime/prelude/string/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/string/mod.rs rename to crates/submilli-engine/src/runtime/prelude/string/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/string/search.rs b/crates/submilli-engine/src/runtime/prelude/string/search.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/string/search.rs rename to crates/submilli-engine/src/runtime/prelude/string/search.rs diff --git a/crates/interpreter/src/runtime/prelude/string/transforms.rs b/crates/submilli-engine/src/runtime/prelude/string/transforms.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/string/transforms.rs rename to crates/submilli-engine/src/runtime/prelude/string/transforms.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/duration/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/duration/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/duration/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/duration/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/duration/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/duration/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/duration/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/duration/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/instant/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/instant/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/instant/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/instant/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/instant/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/instant/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/instant/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/instant/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/now/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/now/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/now/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/now/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/now/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/now/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/now/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/now/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_date/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_date/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_date/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_date/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_date/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_date/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_date/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_date/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_date_time/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_date_time/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_date_time/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_date_time/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_month_day/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_month_day/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_month_day/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_month_day/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_time/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_time/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_time/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_time/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_time/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_time/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_time/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_time/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_year_month/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_year_month/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/plain_year_month/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/plain_year_month/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/shared.rs b/crates/submilli-engine/src/runtime/prelude/temporal/shared.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/shared.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/shared.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE b/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE rename to crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE diff --git a/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/install.rs b/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/install.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/install.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/mod.rs b/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/mod.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs b/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs diff --git a/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs b/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs rename to crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs diff --git a/crates/interpreter/src/runtime/prelude/textcodec/install.rs b/crates/submilli-engine/src/runtime/prelude/textcodec/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/textcodec/install.rs rename to crates/submilli-engine/src/runtime/prelude/textcodec/install.rs diff --git a/crates/interpreter/src/runtime/prelude/textcodec/mod.rs b/crates/submilli-engine/src/runtime/prelude/textcodec/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/textcodec/mod.rs rename to crates/submilli-engine/src/runtime/prelude/textcodec/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/uint8array/install.rs b/crates/submilli-engine/src/runtime/prelude/uint8array/install.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/uint8array/install.rs rename to crates/submilli-engine/src/runtime/prelude/uint8array/install.rs diff --git a/crates/interpreter/src/runtime/prelude/uint8array/mod.rs b/crates/submilli-engine/src/runtime/prelude/uint8array/mod.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/uint8array/mod.rs rename to crates/submilli-engine/src/runtime/prelude/uint8array/mod.rs diff --git a/crates/interpreter/src/runtime/prelude/undefined.rs b/crates/submilli-engine/src/runtime/prelude/undefined.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/undefined.rs rename to crates/submilli-engine/src/runtime/prelude/undefined.rs diff --git a/crates/interpreter/src/runtime/prelude/uri.rs b/crates/submilli-engine/src/runtime/prelude/uri.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/uri.rs rename to crates/submilli-engine/src/runtime/prelude/uri.rs diff --git a/crates/interpreter/src/runtime/prelude/value.rs b/crates/submilli-engine/src/runtime/prelude/value.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/value.rs rename to crates/submilli-engine/src/runtime/prelude/value.rs diff --git a/crates/interpreter/src/runtime/prelude/vtable.rs b/crates/submilli-engine/src/runtime/prelude/vtable.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/vtable.rs rename to crates/submilli-engine/src/runtime/prelude/vtable.rs diff --git a/crates/interpreter/src/runtime/prelude/vtable/serialization.rs b/crates/submilli-engine/src/runtime/prelude/vtable/serialization.rs similarity index 100% rename from crates/interpreter/src/runtime/prelude/vtable/serialization.rs rename to crates/submilli-engine/src/runtime/prelude/vtable/serialization.rs diff --git a/crates/interpreter/src/runtime/secrets.rs b/crates/submilli-engine/src/runtime/secrets.rs similarity index 100% rename from crates/interpreter/src/runtime/secrets.rs rename to crates/submilli-engine/src/runtime/secrets.rs diff --git a/crates/interpreter/src/runtime/security.rs b/crates/submilli-engine/src/runtime/security.rs similarity index 100% rename from crates/interpreter/src/runtime/security.rs rename to crates/submilli-engine/src/runtime/security.rs diff --git a/crates/interpreter/src/runtime/session_kv.rs b/crates/submilli-engine/src/runtime/session_kv.rs similarity index 100% rename from crates/interpreter/src/runtime/session_kv.rs rename to crates/submilli-engine/src/runtime/session_kv.rs diff --git a/crates/interpreter/src/runtime/skills.rs b/crates/submilli-engine/src/runtime/skills.rs similarity index 100% rename from crates/interpreter/src/runtime/skills.rs rename to crates/submilli-engine/src/runtime/skills.rs diff --git a/crates/interpreter/src/runtime/token_ledger.rs b/crates/submilli-engine/src/runtime/token_ledger.rs similarity index 100% rename from crates/interpreter/src/runtime/token_ledger.rs rename to crates/submilli-engine/src/runtime/token_ledger.rs diff --git a/crates/interpreter/src/runtime/vfs.rs b/crates/submilli-engine/src/runtime/vfs.rs similarity index 100% rename from crates/interpreter/src/runtime/vfs.rs rename to crates/submilli-engine/src/runtime/vfs.rs diff --git a/crates/interpreter/src/runtime/watchdog.rs b/crates/submilli-engine/src/runtime/watchdog.rs similarity index 100% rename from crates/interpreter/src/runtime/watchdog.rs rename to crates/submilli-engine/src/runtime/watchdog.rs diff --git a/crates/interpreter/src/shape.rs b/crates/submilli-engine/src/shape.rs similarity index 100% rename from crates/interpreter/src/shape.rs rename to crates/submilli-engine/src/shape.rs diff --git a/crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap b/crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap similarity index 95% rename from crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap index 463d212c2..a57901c53 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/asi.rs +source: crates/submilli-engine/src/asi.rs expression: kinds --- [ diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap similarity index 73% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap index 2503603fd..bc7d0bc1e 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: boom diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap similarity index 73% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap index 4b461495f..c2b3d3a70 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: boom diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap similarity index 87% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap index 243452a87..5a5f3cdea 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: missing return in all code paths diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap similarity index 81% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap index 1a9230c7b..b1420fce1 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: multi-line span diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap similarity index 77% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap index 0ffd33f6d..a61db6a97 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: bad diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap similarity index 82% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap index 121f4d61c..6371f6ecd 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: type mismatch: expected `number`, found `string` diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap similarity index 77% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap index ea6c2a12d..851dd7ff5 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- warning: unused variable `unused` diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap similarity index 82% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap index 4d6dcc735..eed3d1b41 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: field `bar` does not exist on `Foo` diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap similarity index 82% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap index 34af24c86..23a4bc0f0 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: bad diff --git a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap similarity index 73% rename from crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap index 71e7634f3..12d95c5d4 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/diagnostics.rs +source: crates/submilli-engine/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: expected `;` diff --git a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap similarity index 69% rename from crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap index d02ccc179..35d37b310 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/lexer.rs +source: crates/submilli-engine/src/lexer.rs expression: rendered --- error: missing digits in exponent diff --git a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap similarity index 74% rename from crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap index dbc2c65d5..29d60f293 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/lexer.rs +source: crates/submilli-engine/src/lexer.rs expression: rendered --- error: unterminated string literal diff --git a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap similarity index 74% rename from crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap index bb1f71c2f..38b04481d 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/lexer.rs +source: crates/submilli-engine/src/lexer.rs expression: rendered --- error: unterminated template literal diff --git a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap similarity index 96% rename from crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap index 683b3edc6..1062c8d4b 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/lexer.rs +source: crates/submilli-engine/src/lexer.rs expression: kinds --- [ diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap index 5f9f81d60..ac3a6532d 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap index 6f6f07e60..6e9213715 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap similarity index 98% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap index d0719edaf..fbde7e4f2 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap index adde97d35..fc2c6e23f 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap index be4d1d6b8..e39ec8969 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap index 6fd9dee39..c9e5f2bda 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap index 7dd968c68..66b80bc7b 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap index 5edf162a3..3e4c9fa30 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap similarity index 88% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap index a42dd3de3..860f7cae4 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: rendered --- error: expected `;` after expression diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap similarity index 98% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap index 4afc06bb3..f81d5fc12 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap similarity index 99% rename from crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap rename to crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap index 40378203f..37cdb333d 100644 --- a/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap +++ b/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/parser.rs +source: crates/submilli-engine/src/parser.rs expression: ast --- Ast { diff --git a/crates/interpreter/src/source.rs b/crates/submilli-engine/src/source.rs similarity index 100% rename from crates/interpreter/src/source.rs rename to crates/submilli-engine/src/source.rs diff --git a/crates/interpreter/src/source_validation.rs b/crates/submilli-engine/src/source_validation.rs similarity index 100% rename from crates/interpreter/src/source_validation.rs rename to crates/submilli-engine/src/source_validation.rs diff --git a/crates/interpreter/src/span.rs b/crates/submilli-engine/src/span.rs similarity index 100% rename from crates/interpreter/src/span.rs rename to crates/submilli-engine/src/span.rs diff --git a/crates/interpreter/src/stdlib/abi.rs b/crates/submilli-engine/src/stdlib/abi.rs similarity index 100% rename from crates/interpreter/src/stdlib/abi.rs rename to crates/submilli-engine/src/stdlib/abi.rs diff --git a/crates/interpreter/src/stdlib/agents/declaration.rs b/crates/submilli-engine/src/stdlib/agents/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/agents/declaration.rs rename to crates/submilli-engine/src/stdlib/agents/declaration.rs diff --git a/crates/interpreter/src/stdlib/agents/mod.rs b/crates/submilli-engine/src/stdlib/agents/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/agents/mod.rs rename to crates/submilli-engine/src/stdlib/agents/mod.rs diff --git a/crates/interpreter/src/stdlib/capabilities.rs b/crates/submilli-engine/src/stdlib/capabilities.rs similarity index 100% rename from crates/interpreter/src/stdlib/capabilities.rs rename to crates/submilli-engine/src/stdlib/capabilities.rs diff --git a/crates/interpreter/src/stdlib/code/budget.rs b/crates/submilli-engine/src/stdlib/code/budget.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/budget.rs rename to crates/submilli-engine/src/stdlib/code/budget.rs diff --git a/crates/interpreter/src/stdlib/code/declaration.rs b/crates/submilli-engine/src/stdlib/code/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/declaration.rs rename to crates/submilli-engine/src/stdlib/code/declaration.rs diff --git a/crates/interpreter/src/stdlib/code/mod.rs b/crates/submilli-engine/src/stdlib/code/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/mod.rs rename to crates/submilli-engine/src/stdlib/code/mod.rs diff --git a/crates/interpreter/src/stdlib/code/myers.rs b/crates/submilli-engine/src/stdlib/code/myers.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/myers.rs rename to crates/submilli-engine/src/stdlib/code/myers.rs diff --git a/crates/interpreter/src/stdlib/code/patch.rs b/crates/submilli-engine/src/stdlib/code/patch.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/patch.rs rename to crates/submilli-engine/src/stdlib/code/patch.rs diff --git a/crates/interpreter/src/stdlib/code/tests.rs b/crates/submilli-engine/src/stdlib/code/tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/tests.rs rename to crates/submilli-engine/src/stdlib/code/tests.rs diff --git a/crates/interpreter/src/stdlib/code/text.rs b/crates/submilli-engine/src/stdlib/code/text.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/text.rs rename to crates/submilli-engine/src/stdlib/code/text.rs diff --git a/crates/interpreter/src/stdlib/code/walk.rs b/crates/submilli-engine/src/stdlib/code/walk.rs similarity index 100% rename from crates/interpreter/src/stdlib/code/walk.rs rename to crates/submilli-engine/src/stdlib/code/walk.rs diff --git a/crates/interpreter/src/stdlib/crypto.rs b/crates/submilli-engine/src/stdlib/crypto.rs similarity index 100% rename from crates/interpreter/src/stdlib/crypto.rs rename to crates/submilli-engine/src/stdlib/crypto.rs diff --git a/crates/interpreter/src/stdlib/dot_segments.rs b/crates/submilli-engine/src/stdlib/dot_segments.rs similarity index 100% rename from crates/interpreter/src/stdlib/dot_segments.rs rename to crates/submilli-engine/src/stdlib/dot_segments.rs diff --git a/crates/interpreter/src/stdlib/embedding/declaration.rs b/crates/submilli-engine/src/stdlib/embedding/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/embedding/declaration.rs rename to crates/submilli-engine/src/stdlib/embedding/declaration.rs diff --git a/crates/interpreter/src/stdlib/embedding/mod.rs b/crates/submilli-engine/src/stdlib/embedding/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/embedding/mod.rs rename to crates/submilli-engine/src/stdlib/embedding/mod.rs diff --git a/crates/interpreter/src/stdlib/fs/declaration.rs b/crates/submilli-engine/src/stdlib/fs/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/fs/declaration.rs rename to crates/submilli-engine/src/stdlib/fs/declaration.rs diff --git a/crates/interpreter/src/stdlib/fs/handles.rs b/crates/submilli-engine/src/stdlib/fs/handles.rs similarity index 100% rename from crates/interpreter/src/stdlib/fs/handles.rs rename to crates/submilli-engine/src/stdlib/fs/handles.rs diff --git a/crates/interpreter/src/stdlib/fs/mod.rs b/crates/submilli-engine/src/stdlib/fs/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/fs/mod.rs rename to crates/submilli-engine/src/stdlib/fs/mod.rs diff --git a/crates/interpreter/src/stdlib/git/class.rs b/crates/submilli-engine/src/stdlib/git/class.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/class.rs rename to crates/submilli-engine/src/stdlib/git/class.rs diff --git a/crates/interpreter/src/stdlib/git/declaration.rs b/crates/submilli-engine/src/stdlib/git/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/declaration.rs rename to crates/submilli-engine/src/stdlib/git/declaration.rs diff --git a/crates/interpreter/src/stdlib/git/diff.rs b/crates/submilli-engine/src/stdlib/git/diff.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/diff.rs rename to crates/submilli-engine/src/stdlib/git/diff.rs diff --git a/crates/interpreter/src/stdlib/git/history.rs b/crates/submilli-engine/src/stdlib/git/history.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/history.rs rename to crates/submilli-engine/src/stdlib/git/history.rs diff --git a/crates/interpreter/src/stdlib/git/index_limits.rs b/crates/submilli-engine/src/stdlib/git/index_limits.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/index_limits.rs rename to crates/submilli-engine/src/stdlib/git/index_limits.rs diff --git a/crates/interpreter/src/stdlib/git/integration_tests.rs b/crates/submilli-engine/src/stdlib/git/integration_tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/integration_tests.rs rename to crates/submilli-engine/src/stdlib/git/integration_tests.rs diff --git a/crates/interpreter/src/stdlib/git/location.rs b/crates/submilli-engine/src/stdlib/git/location.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/location.rs rename to crates/submilli-engine/src/stdlib/git/location.rs diff --git a/crates/interpreter/src/stdlib/git/lock.rs b/crates/submilli-engine/src/stdlib/git/lock.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/lock.rs rename to crates/submilli-engine/src/stdlib/git/lock.rs diff --git a/crates/interpreter/src/stdlib/git/log_cache.rs b/crates/submilli-engine/src/stdlib/git/log_cache.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/log_cache.rs rename to crates/submilli-engine/src/stdlib/git/log_cache.rs diff --git a/crates/interpreter/src/stdlib/git/metadata_scan.rs b/crates/submilli-engine/src/stdlib/git/metadata_scan.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/metadata_scan.rs rename to crates/submilli-engine/src/stdlib/git/metadata_scan.rs diff --git a/crates/interpreter/src/stdlib/git/meter.rs b/crates/submilli-engine/src/stdlib/git/meter.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/meter.rs rename to crates/submilli-engine/src/stdlib/git/meter.rs diff --git a/crates/interpreter/src/stdlib/git/mod.rs b/crates/submilli-engine/src/stdlib/git/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/mod.rs rename to crates/submilli-engine/src/stdlib/git/mod.rs diff --git a/crates/interpreter/src/stdlib/git/object.rs b/crates/submilli-engine/src/stdlib/git/object.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/object.rs rename to crates/submilli-engine/src/stdlib/git/object.rs diff --git a/crates/interpreter/src/stdlib/git/operations.rs b/crates/submilli-engine/src/stdlib/git/operations.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/operations.rs rename to crates/submilli-engine/src/stdlib/git/operations.rs diff --git a/crates/interpreter/src/stdlib/git/pack_index_check.rs b/crates/submilli-engine/src/stdlib/git/pack_index_check.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/pack_index_check.rs rename to crates/submilli-engine/src/stdlib/git/pack_index_check.rs diff --git a/crates/interpreter/src/stdlib/git/pack_limits.rs b/crates/submilli-engine/src/stdlib/git/pack_limits.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/pack_limits.rs rename to crates/submilli-engine/src/stdlib/git/pack_limits.rs diff --git a/crates/interpreter/src/stdlib/git/stage.rs b/crates/submilli-engine/src/stdlib/git/stage.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/stage.rs rename to crates/submilli-engine/src/stdlib/git/stage.rs diff --git a/crates/interpreter/src/stdlib/git/storage.rs b/crates/submilli-engine/src/stdlib/git/storage.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/storage.rs rename to crates/submilli-engine/src/stdlib/git/storage.rs diff --git a/crates/interpreter/src/stdlib/git/tests.rs b/crates/submilli-engine/src/stdlib/git/tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/tests.rs rename to crates/submilli-engine/src/stdlib/git/tests.rs diff --git a/crates/interpreter/src/stdlib/git/transport.rs b/crates/submilli-engine/src/stdlib/git/transport.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/transport.rs rename to crates/submilli-engine/src/stdlib/git/transport.rs diff --git a/crates/interpreter/src/stdlib/git/work.rs b/crates/submilli-engine/src/stdlib/git/work.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/work.rs rename to crates/submilli-engine/src/stdlib/git/work.rs diff --git a/crates/interpreter/src/stdlib/git/worker.rs b/crates/submilli-engine/src/stdlib/git/worker.rs similarity index 100% rename from crates/interpreter/src/stdlib/git/worker.rs rename to crates/submilli-engine/src/stdlib/git/worker.rs diff --git a/crates/interpreter/src/stdlib/http/declaration.rs b/crates/submilli-engine/src/stdlib/http/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/declaration.rs rename to crates/submilli-engine/src/stdlib/http/declaration.rs diff --git a/crates/interpreter/src/stdlib/http/mod.rs b/crates/submilli-engine/src/stdlib/http/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/mod.rs rename to crates/submilli-engine/src/stdlib/http/mod.rs diff --git a/crates/interpreter/src/stdlib/http/policy.rs b/crates/submilli-engine/src/stdlib/http/policy.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/policy.rs rename to crates/submilli-engine/src/stdlib/http/policy.rs diff --git a/crates/interpreter/src/stdlib/http/redirect_guard.rs b/crates/submilli-engine/src/stdlib/http/redirect_guard.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/redirect_guard.rs rename to crates/submilli-engine/src/stdlib/http/redirect_guard.rs diff --git a/crates/interpreter/src/stdlib/http/transport.rs b/crates/submilli-engine/src/stdlib/http/transport.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/transport.rs rename to crates/submilli-engine/src/stdlib/http/transport.rs diff --git a/crates/interpreter/src/stdlib/http/transport_policy.rs b/crates/submilli-engine/src/stdlib/http/transport_policy.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/transport_policy.rs rename to crates/submilli-engine/src/stdlib/http/transport_policy.rs diff --git a/crates/interpreter/src/stdlib/http/transport_policy_tests.rs b/crates/submilli-engine/src/stdlib/http/transport_policy_tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/transport_policy_tests.rs rename to crates/submilli-engine/src/stdlib/http/transport_policy_tests.rs diff --git a/crates/interpreter/src/stdlib/http/transport_tls_tests.rs b/crates/submilli-engine/src/stdlib/http/transport_tls_tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/http/transport_tls_tests.rs rename to crates/submilli-engine/src/stdlib/http/transport_tls_tests.rs diff --git a/crates/interpreter/src/stdlib/llm/declaration.rs b/crates/submilli-engine/src/stdlib/llm/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/llm/declaration.rs rename to crates/submilli-engine/src/stdlib/llm/declaration.rs diff --git a/crates/interpreter/src/stdlib/llm/mod.rs b/crates/submilli-engine/src/stdlib/llm/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/llm/mod.rs rename to crates/submilli-engine/src/stdlib/llm/mod.rs diff --git a/crates/interpreter/src/stdlib/mod.rs b/crates/submilli-engine/src/stdlib/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/mod.rs rename to crates/submilli-engine/src/stdlib/mod.rs diff --git a/crates/interpreter/src/stdlib/optional_tests.rs b/crates/submilli-engine/src/stdlib/optional_tests.rs similarity index 100% rename from crates/interpreter/src/stdlib/optional_tests.rs rename to crates/submilli-engine/src/stdlib/optional_tests.rs diff --git a/crates/interpreter/src/stdlib/secrets.rs b/crates/submilli-engine/src/stdlib/secrets.rs similarity index 100% rename from crates/interpreter/src/stdlib/secrets.rs rename to crates/submilli-engine/src/stdlib/secrets.rs diff --git a/crates/interpreter/src/stdlib/security.rs b/crates/submilli-engine/src/stdlib/security.rs similarity index 100% rename from crates/interpreter/src/stdlib/security.rs rename to crates/submilli-engine/src/stdlib/security.rs diff --git a/crates/interpreter/src/stdlib/session/cursor.rs b/crates/submilli-engine/src/stdlib/session/cursor.rs similarity index 100% rename from crates/interpreter/src/stdlib/session/cursor.rs rename to crates/submilli-engine/src/stdlib/session/cursor.rs diff --git a/crates/interpreter/src/stdlib/session/declaration.rs b/crates/submilli-engine/src/stdlib/session/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/session/declaration.rs rename to crates/submilli-engine/src/stdlib/session/declaration.rs diff --git a/crates/interpreter/src/stdlib/session/mod.rs b/crates/submilli-engine/src/stdlib/session/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/session/mod.rs rename to crates/submilli-engine/src/stdlib/session/mod.rs diff --git a/crates/interpreter/src/stdlib/session/value.rs b/crates/submilli-engine/src/stdlib/session/value.rs similarity index 100% rename from crates/interpreter/src/stdlib/session/value.rs rename to crates/submilli-engine/src/stdlib/session/value.rs diff --git a/crates/interpreter/src/stdlib/shared.rs b/crates/submilli-engine/src/stdlib/shared.rs similarity index 100% rename from crates/interpreter/src/stdlib/shared.rs rename to crates/submilli-engine/src/stdlib/shared.rs diff --git a/crates/interpreter/src/stdlib/skills/declaration.rs b/crates/submilli-engine/src/stdlib/skills/declaration.rs similarity index 100% rename from crates/interpreter/src/stdlib/skills/declaration.rs rename to crates/submilli-engine/src/stdlib/skills/declaration.rs diff --git a/crates/interpreter/src/stdlib/skills/mod.rs b/crates/submilli-engine/src/stdlib/skills/mod.rs similarity index 100% rename from crates/interpreter/src/stdlib/skills/mod.rs rename to crates/submilli-engine/src/stdlib/skills/mod.rs diff --git a/crates/interpreter/src/stdlib/test.rs b/crates/submilli-engine/src/stdlib/test.rs similarity index 100% rename from crates/interpreter/src/stdlib/test.rs rename to crates/submilli-engine/src/stdlib/test.rs diff --git a/crates/interpreter/src/stdlib/url.rs b/crates/submilli-engine/src/stdlib/url.rs similarity index 100% rename from crates/interpreter/src/stdlib/url.rs rename to crates/submilli-engine/src/stdlib/url.rs diff --git a/crates/interpreter/src/stdlib/uuid.rs b/crates/submilli-engine/src/stdlib/uuid.rs similarity index 100% rename from crates/interpreter/src/stdlib/uuid.rs rename to crates/submilli-engine/src/stdlib/uuid.rs diff --git a/crates/interpreter/src/token.rs b/crates/submilli-engine/src/token.rs similarity index 100% rename from crates/interpreter/src/token.rs rename to crates/submilli-engine/src/token.rs diff --git a/crates/interpreter/src/tree_height.rs b/crates/submilli-engine/src/tree_height.rs similarity index 100% rename from crates/interpreter/src/tree_height.rs rename to crates/submilli-engine/src/tree_height.rs diff --git a/crates/interpreter/src/type_info.rs b/crates/submilli-engine/src/type_info.rs similarity index 100% rename from crates/interpreter/src/type_info.rs rename to crates/submilli-engine/src/type_info.rs diff --git a/crates/interpreter/src/type_rendering.rs b/crates/submilli-engine/src/type_rendering.rs similarity index 100% rename from crates/interpreter/src/type_rendering.rs rename to crates/submilli-engine/src/type_rendering.rs diff --git a/crates/interpreter/src/type_size.rs b/crates/submilli-engine/src/type_size.rs similarity index 100% rename from crates/interpreter/src/type_size.rs rename to crates/submilli-engine/src/type_size.rs diff --git a/crates/interpreter/src/type_walk.rs b/crates/submilli-engine/src/type_walk.rs similarity index 100% rename from crates/interpreter/src/type_walk.rs rename to crates/submilli-engine/src/type_walk.rs diff --git a/crates/interpreter/src/typechecker/capture.rs b/crates/submilli-engine/src/typechecker/capture.rs similarity index 100% rename from crates/interpreter/src/typechecker/capture.rs rename to crates/submilli-engine/src/typechecker/capture.rs diff --git a/crates/interpreter/src/typechecker/desugar/do_while.rs b/crates/submilli-engine/src/typechecker/desugar/do_while.rs similarity index 100% rename from crates/interpreter/src/typechecker/desugar/do_while.rs rename to crates/submilli-engine/src/typechecker/desugar/do_while.rs diff --git a/crates/interpreter/src/typechecker/desugar/for_loop.rs b/crates/submilli-engine/src/typechecker/desugar/for_loop.rs similarity index 100% rename from crates/interpreter/src/typechecker/desugar/for_loop.rs rename to crates/submilli-engine/src/typechecker/desugar/for_loop.rs diff --git a/crates/interpreter/src/typechecker/desugar/for_of.rs b/crates/submilli-engine/src/typechecker/desugar/for_of.rs similarity index 100% rename from crates/interpreter/src/typechecker/desugar/for_of.rs rename to crates/submilli-engine/src/typechecker/desugar/for_of.rs diff --git a/crates/interpreter/src/typechecker/desugar/mod.rs b/crates/submilli-engine/src/typechecker/desugar/mod.rs similarity index 100% rename from crates/interpreter/src/typechecker/desugar/mod.rs rename to crates/submilli-engine/src/typechecker/desugar/mod.rs diff --git a/crates/interpreter/src/typechecker/desugar/postfix_incdec.rs b/crates/submilli-engine/src/typechecker/desugar/postfix_incdec.rs similarity index 100% rename from crates/interpreter/src/typechecker/desugar/postfix_incdec.rs rename to crates/submilli-engine/src/typechecker/desugar/postfix_incdec.rs diff --git a/crates/interpreter/src/typechecker/infer/aliased_conditions.rs b/crates/submilli-engine/src/typechecker/infer/aliased_conditions.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/aliased_conditions.rs rename to crates/submilli-engine/src/typechecker/infer/aliased_conditions.rs diff --git a/crates/interpreter/src/typechecker/infer/assign_expr.rs b/crates/submilli-engine/src/typechecker/infer/assign_expr.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/assign_expr.rs rename to crates/submilli-engine/src/typechecker/infer/assign_expr.rs diff --git a/crates/interpreter/src/typechecker/infer/assignable.rs b/crates/submilli-engine/src/typechecker/infer/assignable.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/assignable.rs rename to crates/submilli-engine/src/typechecker/infer/assignable.rs diff --git a/crates/interpreter/src/typechecker/infer/best_common_type.rs b/crates/submilli-engine/src/typechecker/infer/best_common_type.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/best_common_type.rs rename to crates/submilli-engine/src/typechecker/infer/best_common_type.rs diff --git a/crates/interpreter/src/typechecker/infer/binding_analysis.rs b/crates/submilli-engine/src/typechecker/infer/binding_analysis.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/binding_analysis.rs rename to crates/submilli-engine/src/typechecker/infer/binding_analysis.rs diff --git a/crates/interpreter/src/typechecker/infer/classes.rs b/crates/submilli-engine/src/typechecker/infer/classes.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/classes.rs rename to crates/submilli-engine/src/typechecker/infer/classes.rs diff --git a/crates/interpreter/src/typechecker/infer/closure_arity.rs b/crates/submilli-engine/src/typechecker/infer/closure_arity.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/closure_arity.rs rename to crates/submilli-engine/src/typechecker/infer/closure_arity.rs diff --git a/crates/interpreter/src/typechecker/infer/comparable.rs b/crates/submilli-engine/src/typechecker/infer/comparable.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/comparable.rs rename to crates/submilli-engine/src/typechecker/infer/comparable.rs diff --git a/crates/interpreter/src/typechecker/infer/comparison_operand.rs b/crates/submilli-engine/src/typechecker/infer/comparison_operand.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/comparison_operand.rs rename to crates/submilli-engine/src/typechecker/infer/comparison_operand.rs diff --git a/crates/interpreter/src/typechecker/infer/diagnostics.rs b/crates/submilli-engine/src/typechecker/infer/diagnostics.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/diagnostics.rs rename to crates/submilli-engine/src/typechecker/infer/diagnostics.rs diff --git a/crates/interpreter/src/typechecker/infer/enums.rs b/crates/submilli-engine/src/typechecker/infer/enums.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/enums.rs rename to crates/submilli-engine/src/typechecker/infer/enums.rs diff --git a/crates/interpreter/src/typechecker/infer/exports.rs b/crates/submilli-engine/src/typechecker/infer/exports.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/exports.rs rename to crates/submilli-engine/src/typechecker/infer/exports.rs diff --git a/crates/interpreter/src/typechecker/infer/expr.rs b/crates/submilli-engine/src/typechecker/infer/expr.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/expr.rs rename to crates/submilli-engine/src/typechecker/infer/expr.rs diff --git a/crates/interpreter/src/typechecker/infer/format_definition.rs b/crates/submilli-engine/src/typechecker/infer/format_definition.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/format_definition.rs rename to crates/submilli-engine/src/typechecker/infer/format_definition.rs diff --git a/crates/interpreter/src/typechecker/infer/format_signature.rs b/crates/submilli-engine/src/typechecker/infer/format_signature.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/format_signature.rs rename to crates/submilli-engine/src/typechecker/infer/format_signature.rs diff --git a/crates/interpreter/src/typechecker/infer/forward_globals.rs b/crates/submilli-engine/src/typechecker/infer/forward_globals.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/forward_globals.rs rename to crates/submilli-engine/src/typechecker/infer/forward_globals.rs diff --git a/crates/interpreter/src/typechecker/infer/generic.rs b/crates/submilli-engine/src/typechecker/infer/generic.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/generic.rs rename to crates/submilli-engine/src/typechecker/infer/generic.rs diff --git a/crates/interpreter/src/typechecker/infer/generic_scopes.rs b/crates/submilli-engine/src/typechecker/infer/generic_scopes.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/generic_scopes.rs rename to crates/submilli-engine/src/typechecker/infer/generic_scopes.rs diff --git a/crates/interpreter/src/typechecker/infer/globals.rs b/crates/submilli-engine/src/typechecker/infer/globals.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/globals.rs rename to crates/submilli-engine/src/typechecker/infer/globals.rs diff --git a/crates/interpreter/src/typechecker/infer/iife.rs b/crates/submilli-engine/src/typechecker/infer/iife.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/iife.rs rename to crates/submilli-engine/src/typechecker/infer/iife.rs diff --git a/crates/interpreter/src/typechecker/infer/import_graph.rs b/crates/submilli-engine/src/typechecker/infer/import_graph.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/import_graph.rs rename to crates/submilli-engine/src/typechecker/infer/import_graph.rs diff --git a/crates/interpreter/src/typechecker/infer/imports.rs b/crates/submilli-engine/src/typechecker/infer/imports.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/imports.rs rename to crates/submilli-engine/src/typechecker/infer/imports.rs diff --git a/crates/interpreter/src/typechecker/infer/inference_sources.rs b/crates/submilli-engine/src/typechecker/infer/inference_sources.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/inference_sources.rs rename to crates/submilli-engine/src/typechecker/infer/inference_sources.rs diff --git a/crates/interpreter/src/typechecker/infer/literal_freshness.rs b/crates/submilli-engine/src/typechecker/infer/literal_freshness.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/literal_freshness.rs rename to crates/submilli-engine/src/typechecker/infer/literal_freshness.rs diff --git a/crates/interpreter/src/typechecker/infer/lookup.rs b/crates/submilli-engine/src/typechecker/infer/lookup.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/lookup.rs rename to crates/submilli-engine/src/typechecker/infer/lookup.rs diff --git a/crates/interpreter/src/typechecker/infer/mod.rs b/crates/submilli-engine/src/typechecker/infer/mod.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/mod.rs rename to crates/submilli-engine/src/typechecker/infer/mod.rs diff --git a/crates/interpreter/src/typechecker/infer/module_symbols.rs b/crates/submilli-engine/src/typechecker/infer/module_symbols.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/module_symbols.rs rename to crates/submilli-engine/src/typechecker/infer/module_symbols.rs diff --git a/crates/interpreter/src/typechecker/infer/namespace_symbol.rs b/crates/submilli-engine/src/typechecker/infer/namespace_symbol.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/namespace_symbol.rs rename to crates/submilli-engine/src/typechecker/infer/namespace_symbol.rs diff --git a/crates/interpreter/src/typechecker/infer/narrow_scopes.rs b/crates/submilli-engine/src/typechecker/infer/narrow_scopes.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/narrow_scopes.rs rename to crates/submilli-engine/src/typechecker/infer/narrow_scopes.rs diff --git a/crates/interpreter/src/typechecker/infer/narrowing.rs b/crates/submilli-engine/src/typechecker/infer/narrowing.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/narrowing.rs rename to crates/submilli-engine/src/typechecker/infer/narrowing.rs diff --git a/crates/interpreter/src/typechecker/infer/nested_functions.rs b/crates/submilli-engine/src/typechecker/infer/nested_functions.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/nested_functions.rs rename to crates/submilli-engine/src/typechecker/infer/nested_functions.rs diff --git a/crates/interpreter/src/typechecker/infer/object_normalization.rs b/crates/submilli-engine/src/typechecker/infer/object_normalization.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/object_normalization.rs rename to crates/submilli-engine/src/typechecker/infer/object_normalization.rs diff --git a/crates/interpreter/src/typechecker/infer/param_defaults.rs b/crates/submilli-engine/src/typechecker/infer/param_defaults.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/param_defaults.rs rename to crates/submilli-engine/src/typechecker/infer/param_defaults.rs diff --git a/crates/interpreter/src/typechecker/infer/predicate_envs.rs b/crates/submilli-engine/src/typechecker/infer/predicate_envs.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/predicate_envs.rs rename to crates/submilli-engine/src/typechecker/infer/predicate_envs.rs diff --git a/crates/interpreter/src/typechecker/infer/records.rs b/crates/submilli-engine/src/typechecker/infer/records.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/records.rs rename to crates/submilli-engine/src/typechecker/infer/records.rs diff --git a/crates/interpreter/src/typechecker/infer/reserved.rs b/crates/submilli-engine/src/typechecker/infer/reserved.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/reserved.rs rename to crates/submilli-engine/src/typechecker/infer/reserved.rs diff --git a/crates/interpreter/src/typechecker/infer/resolve_type.rs b/crates/submilli-engine/src/typechecker/infer/resolve_type.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/resolve_type.rs rename to crates/submilli-engine/src/typechecker/infer/resolve_type.rs diff --git a/crates/interpreter/src/typechecker/infer/scopes.rs b/crates/submilli-engine/src/typechecker/infer/scopes.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/scopes.rs rename to crates/submilli-engine/src/typechecker/infer/scopes.rs diff --git a/crates/interpreter/src/typechecker/infer/shapes.rs b/crates/submilli-engine/src/typechecker/infer/shapes.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/shapes.rs rename to crates/submilli-engine/src/typechecker/infer/shapes.rs diff --git a/crates/interpreter/src/typechecker/infer/signatures.rs b/crates/submilli-engine/src/typechecker/infer/signatures.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/signatures.rs rename to crates/submilli-engine/src/typechecker/infer/signatures.rs diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap similarity index 99% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap index eb7c33cbe..62c2b905d 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/expr.rs +source: crates/submilli-engine/src/typechecker/infer/expr.rs assertion_line: 11231 expression: ta --- diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap similarity index 60% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap index a4a703904..bcd62830a 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/format_definition.rs +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs expression: out --- interface Array { diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap new file mode 100644 index 000000000..f5543fdb4 --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap @@ -0,0 +1,5 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +(arg0: number, arg1: string) => boolean diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap similarity index 53% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap index d6ff091b3..df4e0964b 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/format_definition.rs +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs expression: out --- interface Map { diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap new file mode 100644 index 000000000..77de6f710 --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap @@ -0,0 +1,7 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Box { + label?: string; +} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap new file mode 100644 index 000000000..f2e576e2e --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap @@ -0,0 +1,8 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Item { + key: number; + tag: string; +} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap new file mode 100644 index 000000000..9c789d92d --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap @@ -0,0 +1,7 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Cell { + value: number; +} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap new file mode 100644 index 000000000..143194942 --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap @@ -0,0 +1,8 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +{ + name: string; + x: number; +} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap new file mode 100644 index 000000000..d12577e0e --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap @@ -0,0 +1,7 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Number { + toString(): string; +} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap similarity index 53% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap index ed2c2118b..d43c20a8b 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- arity: expected at most 1 param(s), got 2 diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap similarity index 70% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap index c36ad68ad..e33f0b2b3 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- arity: expected at most 2 param(s), got 3 diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap similarity index 52% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap index b5bc1e8bc..7cf47a6c8 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- param 2: expected `string`, got `number` diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap similarity index 52% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap index 188385882..10e8dd9fe 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- return: expected `number`, got `string` diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap similarity index 67% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap index 446efaf94..2327c2cb1 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- missing field(s): `y` diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap new file mode 100644 index 000000000..2970110c7 --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap @@ -0,0 +1,5 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +expression: out.unwrap() +--- +extra field(s): `y` diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap similarity index 59% rename from crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap rename to crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap index a5364cc68..54c77723d 100644 --- a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/src/typechecker/infer/type_diff.rs +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- field type mismatches: diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap new file mode 100644 index 000000000..06e04df34 --- /dev/null +++ b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap @@ -0,0 +1,5 @@ +--- +source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +expression: out.unwrap() +--- +missing field(s): `y` diff --git a/crates/interpreter/src/typechecker/infer/stmt.rs b/crates/submilli-engine/src/typechecker/infer/stmt.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/stmt.rs rename to crates/submilli-engine/src/typechecker/infer/stmt.rs diff --git a/crates/interpreter/src/typechecker/infer/switch_stmt.rs b/crates/submilli-engine/src/typechecker/infer/switch_stmt.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/switch_stmt.rs rename to crates/submilli-engine/src/typechecker/infer/switch_stmt.rs diff --git a/crates/interpreter/src/typechecker/infer/test_support.rs b/crates/submilli-engine/src/typechecker/infer/test_support.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/test_support.rs rename to crates/submilli-engine/src/typechecker/infer/test_support.rs diff --git a/crates/interpreter/src/typechecker/infer/type_aliases.rs b/crates/submilli-engine/src/typechecker/infer/type_aliases.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/type_aliases.rs rename to crates/submilli-engine/src/typechecker/infer/type_aliases.rs diff --git a/crates/interpreter/src/typechecker/infer/type_diff.rs b/crates/submilli-engine/src/typechecker/infer/type_diff.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/type_diff.rs rename to crates/submilli-engine/src/typechecker/infer/type_diff.rs diff --git a/crates/interpreter/src/typechecker/infer/type_namespace.rs b/crates/submilli-engine/src/typechecker/infer/type_namespace.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/type_namespace.rs rename to crates/submilli-engine/src/typechecker/infer/type_namespace.rs diff --git a/crates/interpreter/src/typechecker/infer/type_predicate.rs b/crates/submilli-engine/src/typechecker/infer/type_predicate.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/type_predicate.rs rename to crates/submilli-engine/src/typechecker/infer/type_predicate.rs diff --git a/crates/interpreter/src/typechecker/infer/type_registry.rs b/crates/submilli-engine/src/typechecker/infer/type_registry.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/type_registry.rs rename to crates/submilli-engine/src/typechecker/infer/type_registry.rs diff --git a/crates/interpreter/src/typechecker/infer/value_operand.rs b/crates/submilli-engine/src/typechecker/infer/value_operand.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/value_operand.rs rename to crates/submilli-engine/src/typechecker/infer/value_operand.rs diff --git a/crates/interpreter/src/typechecker/infer/variance.rs b/crates/submilli-engine/src/typechecker/infer/variance.rs similarity index 100% rename from crates/interpreter/src/typechecker/infer/variance.rs rename to crates/submilli-engine/src/typechecker/infer/variance.rs diff --git a/crates/interpreter/src/typechecker/json_schema.rs b/crates/submilli-engine/src/typechecker/json_schema.rs similarity index 100% rename from crates/interpreter/src/typechecker/json_schema.rs rename to crates/submilli-engine/src/typechecker/json_schema.rs diff --git a/crates/interpreter/src/typechecker/json_strategy.rs b/crates/submilli-engine/src/typechecker/json_strategy.rs similarity index 100% rename from crates/interpreter/src/typechecker/json_strategy.rs rename to crates/submilli-engine/src/typechecker/json_strategy.rs diff --git a/crates/interpreter/src/typechecker/mod.rs b/crates/submilli-engine/src/typechecker/mod.rs similarity index 100% rename from crates/interpreter/src/typechecker/mod.rs rename to crates/submilli-engine/src/typechecker/mod.rs diff --git a/crates/interpreter/src/typechecker/rules/body_walk.rs b/crates/submilli-engine/src/typechecker/rules/body_walk.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/body_walk.rs rename to crates/submilli-engine/src/typechecker/rules/body_walk.rs diff --git a/crates/interpreter/src/typechecker/rules/capability_consistency.rs b/crates/submilli-engine/src/typechecker/rules/capability_consistency.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/capability_consistency.rs rename to crates/submilli-engine/src/typechecker/rules/capability_consistency.rs diff --git a/crates/interpreter/src/typechecker/rules/check_calls.rs b/crates/submilli-engine/src/typechecker/rules/check_calls.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_calls.rs rename to crates/submilli-engine/src/typechecker/rules/check_calls.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/bodies.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/bodies.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/bodies.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/bodies.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/checked.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/checked.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/checked.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/checked.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/findings.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/findings.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/findings.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/findings.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/flow.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/flow.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/flow.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/flow.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/mod.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/mod.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/mod.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/mod.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/origin.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/origin.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/origin.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/origin.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/package.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/package.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/package.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/package.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/scope.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/scope.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/scope.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/scope.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/stability.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/stability.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/stability.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/stability.rs diff --git a/crates/interpreter/src/typechecker/rules/check_discipline/tests.rs b/crates/submilli-engine/src/typechecker/rules/check_discipline/tests.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/check_discipline/tests.rs rename to crates/submilli-engine/src/typechecker/rules/check_discipline/tests.rs diff --git a/crates/interpreter/src/typechecker/rules/control_flow.rs b/crates/submilli-engine/src/typechecker/rules/control_flow.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/control_flow.rs rename to crates/submilli-engine/src/typechecker/rules/control_flow.rs diff --git a/crates/interpreter/src/typechecker/rules/declarations.rs b/crates/submilli-engine/src/typechecker/rules/declarations.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/declarations.rs rename to crates/submilli-engine/src/typechecker/rules/declarations.rs diff --git a/crates/interpreter/src/typechecker/rules/definite_assignment.rs b/crates/submilli-engine/src/typechecker/rules/definite_assignment.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/definite_assignment.rs rename to crates/submilli-engine/src/typechecker/rules/definite_assignment.rs diff --git a/crates/interpreter/src/typechecker/rules/doc_consistency.rs b/crates/submilli-engine/src/typechecker/rules/doc_consistency.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/doc_consistency.rs rename to crates/submilli-engine/src/typechecker/rules/doc_consistency.rs diff --git a/crates/interpreter/src/typechecker/rules/exported_docs.rs b/crates/submilli-engine/src/typechecker/rules/exported_docs.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/exported_docs.rs rename to crates/submilli-engine/src/typechecker/rules/exported_docs.rs diff --git a/crates/interpreter/src/typechecker/rules/exported_signature_types.rs b/crates/submilli-engine/src/typechecker/rules/exported_signature_types.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/exported_signature_types.rs rename to crates/submilli-engine/src/typechecker/rules/exported_signature_types.rs diff --git a/crates/interpreter/src/typechecker/rules/fallthrough.rs b/crates/submilli-engine/src/typechecker/rules/fallthrough.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/fallthrough.rs rename to crates/submilli-engine/src/typechecker/rules/fallthrough.rs diff --git a/crates/interpreter/src/typechecker/rules/main_required.rs b/crates/submilli-engine/src/typechecker/rules/main_required.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/main_required.rs rename to crates/submilli-engine/src/typechecker/rules/main_required.rs diff --git a/crates/interpreter/src/typechecker/rules/missing_return.rs b/crates/submilli-engine/src/typechecker/rules/missing_return.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/missing_return.rs rename to crates/submilli-engine/src/typechecker/rules/missing_return.rs diff --git a/crates/interpreter/src/typechecker/rules/mod.rs b/crates/submilli-engine/src/typechecker/rules/mod.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/mod.rs rename to crates/submilli-engine/src/typechecker/rules/mod.rs diff --git a/crates/interpreter/src/typechecker/rules/return_outside_function.rs b/crates/submilli-engine/src/typechecker/rules/return_outside_function.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/return_outside_function.rs rename to crates/submilli-engine/src/typechecker/rules/return_outside_function.rs diff --git a/crates/interpreter/src/typechecker/rules/super_call.rs b/crates/submilli-engine/src/typechecker/rules/super_call.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/super_call.rs rename to crates/submilli-engine/src/typechecker/rules/super_call.rs diff --git a/crates/interpreter/src/typechecker/rules/unreachable.rs b/crates/submilli-engine/src/typechecker/rules/unreachable.rs similarity index 100% rename from crates/interpreter/src/typechecker/rules/unreachable.rs rename to crates/submilli-engine/src/typechecker/rules/unreachable.rs diff --git a/crates/interpreter/src/typechecker/type_param_substitution.rs b/crates/submilli-engine/src/typechecker/type_param_substitution.rs similarity index 100% rename from crates/interpreter/src/typechecker/type_param_substitution.rs rename to crates/submilli-engine/src/typechecker/type_param_substitution.rs diff --git a/crates/interpreter/src/typed_ast.rs b/crates/submilli-engine/src/typed_ast.rs similarity index 100% rename from crates/interpreter/src/typed_ast.rs rename to crates/submilli-engine/src/typed_ast.rs diff --git a/crates/interpreter/src/types.rs b/crates/submilli-engine/src/types.rs similarity index 100% rename from crates/interpreter/src/types.rs rename to crates/submilli-engine/src/types.rs diff --git a/crates/interpreter/tests/checked_arena.rs b/crates/submilli-engine/tests/checked_arena.rs similarity index 100% rename from crates/interpreter/tests/checked_arena.rs rename to crates/submilli-engine/tests/checked_arena.rs diff --git a/crates/interpreter/tests/checked_rendering.rs b/crates/submilli-engine/tests/checked_rendering.rs similarity index 100% rename from crates/interpreter/tests/checked_rendering.rs rename to crates/submilli-engine/tests/checked_rendering.rs diff --git a/crates/interpreter/tests/checked_source.rs b/crates/submilli-engine/tests/checked_source.rs similarity index 100% rename from crates/interpreter/tests/checked_source.rs rename to crates/submilli-engine/tests/checked_source.rs diff --git a/crates/interpreter/tests/checked_typed_phases.rs b/crates/submilli-engine/tests/checked_typed_phases.rs similarity index 100% rename from crates/interpreter/tests/checked_typed_phases.rs rename to crates/submilli-engine/tests/checked_typed_phases.rs diff --git a/crates/interpreter/tests/checked_untyped_phases.rs b/crates/submilli-engine/tests/checked_untyped_phases.rs similarity index 100% rename from crates/interpreter/tests/checked_untyped_phases.rs rename to crates/submilli-engine/tests/checked_untyped_phases.rs diff --git a/crates/interpreter/tests/class_rec_group.rs b/crates/submilli-engine/tests/class_rec_group.rs similarity index 100% rename from crates/interpreter/tests/class_rec_group.rs rename to crates/submilli-engine/tests/class_rec_group.rs diff --git a/crates/interpreter/tests/closure_arity.rs b/crates/submilli-engine/tests/closure_arity.rs similarity index 100% rename from crates/interpreter/tests/closure_arity.rs rename to crates/submilli-engine/tests/closure_arity.rs diff --git a/crates/interpreter/tests/closure_arity_diagnostics.rs b/crates/submilli-engine/tests/closure_arity_diagnostics.rs similarity index 100% rename from crates/interpreter/tests/closure_arity_diagnostics.rs rename to crates/submilli-engine/tests/closure_arity_diagnostics.rs diff --git a/crates/interpreter/tests/closure_lowering_errors.rs b/crates/submilli-engine/tests/closure_lowering_errors.rs similarity index 100% rename from crates/interpreter/tests/closure_lowering_errors.rs rename to crates/submilli-engine/tests/closure_lowering_errors.rs diff --git a/crates/interpreter/tests/compiler_structure_limits.rs b/crates/submilli-engine/tests/compiler_structure_limits.rs similarity index 100% rename from crates/interpreter/tests/compiler_structure_limits.rs rename to crates/submilli-engine/tests/compiler_structure_limits.rs diff --git a/crates/interpreter/tests/console_failure.rs b/crates/submilli-engine/tests/console_failure.rs similarity index 100% rename from crates/interpreter/tests/console_failure.rs rename to crates/submilli-engine/tests/console_failure.rs diff --git a/crates/interpreter/tests/cross_module_gc_types.rs b/crates/submilli-engine/tests/cross_module_gc_types.rs similarity index 100% rename from crates/interpreter/tests/cross_module_gc_types.rs rename to crates/submilli-engine/tests/cross_module_gc_types.rs diff --git a/crates/interpreter/tests/decision_records.rs b/crates/submilli-engine/tests/decision_records.rs similarity index 100% rename from crates/interpreter/tests/decision_records.rs rename to crates/submilli-engine/tests/decision_records.rs diff --git a/crates/interpreter/tests/determinism.rs b/crates/submilli-engine/tests/determinism.rs similarity index 100% rename from crates/interpreter/tests/determinism.rs rename to crates/submilli-engine/tests/determinism.rs diff --git a/crates/interpreter/tests/diagnostic_snapshots.rs b/crates/submilli-engine/tests/diagnostic_snapshots.rs similarity index 100% rename from crates/interpreter/tests/diagnostic_snapshots.rs rename to crates/submilli-engine/tests/diagnostic_snapshots.rs diff --git a/crates/interpreter/tests/field_lookup_size.rs b/crates/submilli-engine/tests/field_lookup_size.rs similarity index 100% rename from crates/interpreter/tests/field_lookup_size.rs rename to crates/submilli-engine/tests/field_lookup_size.rs diff --git a/crates/interpreter/tests/fixtures.rs b/crates/submilli-engine/tests/fixtures.rs similarity index 100% rename from crates/interpreter/tests/fixtures.rs rename to crates/submilli-engine/tests/fixtures.rs diff --git a/crates/interpreter/tests/fixtures/alias_index_read_write.ts b/crates/submilli-engine/tests/fixtures/alias_index_read_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/alias_index_read_write.ts rename to crates/submilli-engine/tests/fixtures/alias_index_read_write.ts diff --git a/crates/interpreter/tests/fixtures/alias_peel_dispatch.ts b/crates/submilli-engine/tests/fixtures/alias_peel_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/alias_peel_dispatch.ts rename to crates/submilli-engine/tests/fixtures/alias_peel_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/angle_bracket_cast.ts b/crates/submilli-engine/tests/fixtures/angle_bracket_cast.ts similarity index 100% rename from crates/interpreter/tests/fixtures/angle_bracket_cast.ts rename to crates/submilli-engine/tests/fixtures/angle_bracket_cast.ts diff --git a/crates/interpreter/tests/fixtures/array_at.subm b/crates/submilli-engine/tests/fixtures/array_at.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_at.subm rename to crates/submilli-engine/tests/fixtures/array_at.subm diff --git a/crates/interpreter/tests/fixtures/array_callback_truthiness.ts b/crates/submilli-engine/tests/fixtures/array_callback_truthiness.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_callback_truthiness.ts rename to crates/submilli-engine/tests/fixtures/array_callback_truthiness.ts diff --git a/crates/interpreter/tests/fixtures/array_concat.subm b/crates/submilli-engine/tests/fixtures/array_concat.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_concat.subm rename to crates/submilli-engine/tests/fixtures/array_concat.subm diff --git a/crates/interpreter/tests/fixtures/array_copy_within.subm b/crates/submilli-engine/tests/fixtures/array_copy_within.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_copy_within.subm rename to crates/submilli-engine/tests/fixtures/array_copy_within.subm diff --git a/crates/interpreter/tests/fixtures/array_every.subm b/crates/submilli-engine/tests/fixtures/array_every.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_every.subm rename to crates/submilli-engine/tests/fixtures/array_every.subm diff --git a/crates/interpreter/tests/fixtures/array_fill.subm b/crates/submilli-engine/tests/fixtures/array_fill.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_fill.subm rename to crates/submilli-engine/tests/fixtures/array_fill.subm diff --git a/crates/interpreter/tests/fixtures/array_filter.subm b/crates/submilli-engine/tests/fixtures/array_filter.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_filter.subm rename to crates/submilli-engine/tests/fixtures/array_filter.subm diff --git a/crates/interpreter/tests/fixtures/array_filter_guard_narrows_to_class.ts b/crates/submilli-engine/tests/fixtures/array_filter_guard_narrows_to_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_filter_guard_narrows_to_class.ts rename to crates/submilli-engine/tests/fixtures/array_filter_guard_narrows_to_class.ts diff --git a/crates/interpreter/tests/fixtures/array_filter_type_guard_narrows.ts b/crates/submilli-engine/tests/fixtures/array_filter_type_guard_narrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_filter_type_guard_narrows.ts rename to crates/submilli-engine/tests/fixtures/array_filter_type_guard_narrows.ts diff --git a/crates/interpreter/tests/fixtures/array_find.subm b/crates/submilli-engine/tests/fixtures/array_find.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_find.subm rename to crates/submilli-engine/tests/fixtures/array_find.subm diff --git a/crates/interpreter/tests/fixtures/array_findindex.subm b/crates/submilli-engine/tests/fixtures/array_findindex.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_findindex.subm rename to crates/submilli-engine/tests/fixtures/array_findindex.subm diff --git a/crates/interpreter/tests/fixtures/array_flat.subm b/crates/submilli-engine/tests/fixtures/array_flat.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_flat.subm rename to crates/submilli-engine/tests/fixtures/array_flat.subm diff --git a/crates/interpreter/tests/fixtures/array_flat_depth_budget.ts b/crates/submilli-engine/tests/fixtures/array_flat_depth_budget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_flat_depth_budget.ts rename to crates/submilli-engine/tests/fixtures/array_flat_depth_budget.ts diff --git a/crates/interpreter/tests/fixtures/array_flat_depth_error.subm b/crates/submilli-engine/tests/fixtures/array_flat_depth_error.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_flat_depth_error.subm rename to crates/submilli-engine/tests/fixtures/array_flat_depth_error.subm diff --git a/crates/interpreter/tests/fixtures/array_flatmap.subm b/crates/submilli-engine/tests/fixtures/array_flatmap.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_flatmap.subm rename to crates/submilli-engine/tests/fixtures/array_flatmap.subm diff --git a/crates/interpreter/tests/fixtures/array_for_each.subm b/crates/submilli-engine/tests/fixtures/array_for_each.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_for_each.subm rename to crates/submilli-engine/tests/fixtures/array_for_each.subm diff --git a/crates/interpreter/tests/fixtures/array_from.subm b/crates/submilli-engine/tests/fixtures/array_from.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_from.subm rename to crates/submilli-engine/tests/fixtures/array_from.subm diff --git a/crates/interpreter/tests/fixtures/array_from_array_like_length.ts b/crates/submilli-engine/tests/fixtures/array_from_array_like_length.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_from_array_like_length.ts rename to crates/submilli-engine/tests/fixtures/array_from_array_like_length.ts diff --git a/crates/interpreter/tests/fixtures/array_from_array_like_wider_source.ts b/crates/submilli-engine/tests/fixtures/array_from_array_like_wider_source.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_from_array_like_wider_source.ts rename to crates/submilli-engine/tests/fixtures/array_from_array_like_wider_source.ts diff --git a/crates/interpreter/tests/fixtures/array_from_collections.ts b/crates/submilli-engine/tests/fixtures/array_from_collections.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_from_collections.ts rename to crates/submilli-engine/tests/fixtures/array_from_collections.ts diff --git a/crates/interpreter/tests/fixtures/array_generic_spelling.subm b/crates/submilli-engine/tests/fixtures/array_generic_spelling.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_generic_spelling.subm rename to crates/submilli-engine/tests/fixtures/array_generic_spelling.subm diff --git a/crates/interpreter/tests/fixtures/array_host_port_edges.ts b/crates/submilli-engine/tests/fixtures/array_host_port_edges.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_host_port_edges.ts rename to crates/submilli-engine/tests/fixtures/array_host_port_edges.ts diff --git a/crates/interpreter/tests/fixtures/array_includes.subm b/crates/submilli-engine/tests/fixtures/array_includes.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_includes.subm rename to crates/submilli-engine/tests/fixtures/array_includes.subm diff --git a/crates/interpreter/tests/fixtures/array_index_domain.ts b/crates/submilli-engine/tests/fixtures/array_index_domain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_index_domain.ts rename to crates/submilli-engine/tests/fixtures/array_index_domain.ts diff --git a/crates/interpreter/tests/fixtures/array_index_of.subm b/crates/submilli-engine/tests/fixtures/array_index_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_index_of.subm rename to crates/submilli-engine/tests/fixtures/array_index_of.subm diff --git a/crates/interpreter/tests/fixtures/array_index_oob_throws.subm b/crates/submilli-engine/tests/fixtures/array_index_oob_throws.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_index_oob_throws.subm rename to crates/submilli-engine/tests/fixtures/array_index_oob_throws.subm diff --git a/crates/interpreter/tests/fixtures/array_indexed_write_rhs_grows.ts b/crates/submilli-engine/tests/fixtures/array_indexed_write_rhs_grows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_indexed_write_rhs_grows.ts rename to crates/submilli-engine/tests/fixtures/array_indexed_write_rhs_grows.ts diff --git a/crates/interpreter/tests/fixtures/array_iter_next_result.ts b/crates/submilli-engine/tests/fixtures/array_iter_next_result.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_iter_next_result.ts rename to crates/submilli-engine/tests/fixtures/array_iter_next_result.ts diff --git a/crates/interpreter/tests/fixtures/array_join.subm b/crates/submilli-engine/tests/fixtures/array_join.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_join.subm rename to crates/submilli-engine/tests/fixtures/array_join.subm diff --git a/crates/interpreter/tests/fixtures/array_join_null.ts b/crates/submilli-engine/tests/fixtures/array_join_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_join_null.ts rename to crates/submilli-engine/tests/fixtures/array_join_null.ts diff --git a/crates/interpreter/tests/fixtures/array_keeps_regular_literal_types.ts b/crates/submilli-engine/tests/fixtures/array_keeps_regular_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_keeps_regular_literal_types.ts rename to crates/submilli-engine/tests/fixtures/array_keeps_regular_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/array_keys_values_entries.subm b/crates/submilli-engine/tests/fixtures/array_keys_values_entries.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_keys_values_entries.subm rename to crates/submilli-engine/tests/fixtures/array_keys_values_entries.subm diff --git a/crates/interpreter/tests/fixtures/array_last_index_of.subm b/crates/submilli-engine/tests/fixtures/array_last_index_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_last_index_of.subm rename to crates/submilli-engine/tests/fixtures/array_last_index_of.subm diff --git a/crates/interpreter/tests/fixtures/array_length.subm b/crates/submilli-engine/tests/fixtures/array_length.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_length.subm rename to crates/submilli-engine/tests/fixtures/array_length.subm diff --git a/crates/interpreter/tests/fixtures/array_like_union_reads.ts b/crates/submilli-engine/tests/fixtures/array_like_union_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_like_union_reads.ts rename to crates/submilli-engine/tests/fixtures/array_like_union_reads.ts diff --git a/crates/interpreter/tests/fixtures/array_like_union_writes.ts b/crates/submilli-engine/tests/fixtures/array_like_union_writes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_like_union_writes.ts rename to crates/submilli-engine/tests/fixtures/array_like_union_writes.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_best_common_type.ts b/crates/submilli-engine/tests/fixtures/array_literal_best_common_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_best_common_type.ts rename to crates/submilli-engine/tests/fixtures/array_literal_best_common_type.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_element_order.ts b/crates/submilli-engine/tests/fixtures/array_literal_element_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_element_order.ts rename to crates/submilli-engine/tests/fixtures/array_literal_element_order.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_normalized_to_optional.ts b/crates/submilli-engine/tests/fixtures/array_literal_normalized_to_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_normalized_to_optional.ts rename to crates/submilli-engine/tests/fixtures/array_literal_normalized_to_optional.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_object_normalization.ts b/crates/submilli-engine/tests/fixtures/array_literal_object_normalization.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_object_normalization.ts rename to crates/submilli-engine/tests/fixtures/array_literal_object_normalization.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_object_normalization_fresh_only.ts b/crates/submilli-engine/tests/fixtures/array_literal_object_normalization_fresh_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_object_normalization_fresh_only.ts rename to crates/submilli-engine/tests/fixtures/array_literal_object_normalization_fresh_only.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_union_of_arrays.ts b/crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_union_of_arrays.ts rename to crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_union_of_arrays_mismatch.ts b/crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_union_of_arrays_mismatch.ts rename to crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_wider_element.ts b/crates/submilli-engine/tests/fixtures/array_literal_wider_element.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_wider_element.ts rename to crates/submilli-engine/tests/fixtures/array_literal_wider_element.ts diff --git a/crates/interpreter/tests/fixtures/array_literal_wider_element_mismatch.ts b/crates/submilli-engine/tests/fixtures/array_literal_wider_element_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_literal_wider_element_mismatch.ts rename to crates/submilli-engine/tests/fixtures/array_literal_wider_element_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/array_map.subm b/crates/submilli-engine/tests/fixtures/array_map.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_map.subm rename to crates/submilli-engine/tests/fixtures/array_map.subm diff --git a/crates/interpreter/tests/fixtures/array_of.subm b/crates/submilli-engine/tests/fixtures/array_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_of.subm rename to crates/submilli-engine/tests/fixtures/array_of.subm diff --git a/crates/interpreter/tests/fixtures/array_of_object_literal_arrays_union.ts b/crates/submilli-engine/tests/fixtures/array_of_object_literal_arrays_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_of_object_literal_arrays_union.ts rename to crates/submilli-engine/tests/fixtures/array_of_object_literal_arrays_union.ts diff --git a/crates/interpreter/tests/fixtures/array_pop.subm b/crates/submilli-engine/tests/fixtures/array_pop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_pop.subm rename to crates/submilli-engine/tests/fixtures/array_pop.subm diff --git a/crates/interpreter/tests/fixtures/array_push.subm b/crates/submilli-engine/tests/fixtures/array_push.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_push.subm rename to crates/submilli-engine/tests/fixtures/array_push.subm diff --git a/crates/interpreter/tests/fixtures/array_reduce.subm b/crates/submilli-engine/tests/fixtures/array_reduce.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_reduce.subm rename to crates/submilli-engine/tests/fixtures/array_reduce.subm diff --git a/crates/interpreter/tests/fixtures/array_reduce_right.subm b/crates/submilli-engine/tests/fixtures/array_reduce_right.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_reduce_right.subm rename to crates/submilli-engine/tests/fixtures/array_reduce_right.subm diff --git a/crates/interpreter/tests/fixtures/array_reverse.subm b/crates/submilli-engine/tests/fixtures/array_reverse.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_reverse.subm rename to crates/submilli-engine/tests/fixtures/array_reverse.subm diff --git a/crates/interpreter/tests/fixtures/array_shift_unshift.subm b/crates/submilli-engine/tests/fixtures/array_shift_unshift.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_shift_unshift.subm rename to crates/submilli-engine/tests/fixtures/array_shift_unshift.subm diff --git a/crates/interpreter/tests/fixtures/array_slice.subm b/crates/submilli-engine/tests/fixtures/array_slice.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_slice.subm rename to crates/submilli-engine/tests/fixtures/array_slice.subm diff --git a/crates/interpreter/tests/fixtures/array_some.subm b/crates/submilli-engine/tests/fixtures/array_some.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_some.subm rename to crates/submilli-engine/tests/fixtures/array_some.subm diff --git a/crates/interpreter/tests/fixtures/array_sort.subm b/crates/submilli-engine/tests/fixtures/array_sort.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_sort.subm rename to crates/submilli-engine/tests/fixtures/array_sort.subm diff --git a/crates/interpreter/tests/fixtures/array_sort_cached_units.ts b/crates/submilli-engine/tests/fixtures/array_sort_cached_units.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_sort_cached_units.ts rename to crates/submilli-engine/tests/fixtures/array_sort_cached_units.ts diff --git a/crates/interpreter/tests/fixtures/array_sort_keeps_comparator_pushes.ts b/crates/submilli-engine/tests/fixtures/array_sort_keeps_comparator_pushes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_sort_keeps_comparator_pushes.ts rename to crates/submilli-engine/tests/fixtures/array_sort_keeps_comparator_pushes.ts diff --git a/crates/interpreter/tests/fixtures/array_sort_stable_merge.ts b/crates/submilli-engine/tests/fixtures/array_sort_stable_merge.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_sort_stable_merge.ts rename to crates/submilli-engine/tests/fixtures/array_sort_stable_merge.ts diff --git a/crates/interpreter/tests/fixtures/array_splice.subm b/crates/submilli-engine/tests/fixtures/array_splice.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_splice.subm rename to crates/submilli-engine/tests/fixtures/array_splice.subm diff --git a/crates/interpreter/tests/fixtures/array_spread_parameter.ts b/crates/submilli-engine/tests/fixtures/array_spread_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_spread_parameter.ts rename to crates/submilli-engine/tests/fixtures/array_spread_parameter.ts diff --git a/crates/interpreter/tests/fixtures/array_to_reversed.subm b/crates/submilli-engine/tests/fixtures/array_to_reversed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_to_reversed.subm rename to crates/submilli-engine/tests/fixtures/array_to_reversed.subm diff --git a/crates/interpreter/tests/fixtures/array_to_sorted.subm b/crates/submilli-engine/tests/fixtures/array_to_sorted.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_to_sorted.subm rename to crates/submilli-engine/tests/fixtures/array_to_sorted.subm diff --git a/crates/interpreter/tests/fixtures/array_to_spliced.subm b/crates/submilli-engine/tests/fixtures/array_to_spliced.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_to_spliced.subm rename to crates/submilli-engine/tests/fixtures/array_to_spliced.subm diff --git a/crates/interpreter/tests/fixtures/array_values_host_iter.ts b/crates/submilli-engine/tests/fixtures/array_values_host_iter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/array_values_host_iter.ts rename to crates/submilli-engine/tests/fixtures/array_values_host_iter.ts diff --git a/crates/interpreter/tests/fixtures/array_with.subm b/crates/submilli-engine/tests/fixtures/array_with.subm similarity index 100% rename from crates/interpreter/tests/fixtures/array_with.subm rename to crates/submilli-engine/tests/fixtures/array_with.subm diff --git a/crates/interpreter/tests/fixtures/arrow_return_type_forms.ts b/crates/submilli-engine/tests/fixtures/arrow_return_type_forms.ts similarity index 100% rename from crates/interpreter/tests/fixtures/arrow_return_type_forms.ts rename to crates/submilli-engine/tests/fixtures/arrow_return_type_forms.ts diff --git a/crates/interpreter/tests/fixtures/asi_allman_braces.ts b/crates/submilli-engine/tests/fixtures/asi_allman_braces.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_allman_braces.ts rename to crates/submilli-engine/tests/fixtures/asi_allman_braces.ts diff --git a/crates/interpreter/tests/fixtures/asi_clause_and_arrow_wraps.ts b/crates/submilli-engine/tests/fixtures/asi_clause_and_arrow_wraps.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_clause_and_arrow_wraps.ts rename to crates/submilli-engine/tests/fixtures/asi_clause_and_arrow_wraps.ts diff --git a/crates/interpreter/tests/fixtures/asi_keyword_members.ts b/crates/submilli-engine/tests/fixtures/asi_keyword_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_keyword_members.ts rename to crates/submilli-engine/tests/fixtures/asi_keyword_members.ts diff --git a/crates/interpreter/tests/fixtures/asi_line_break_after_as_type.ts b/crates/submilli-engine/tests/fixtures/asi_line_break_after_as_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_line_break_after_as_type.ts rename to crates/submilli-engine/tests/fixtures/asi_line_break_after_as_type.ts diff --git a/crates/interpreter/tests/fixtures/asi_line_wrapped_operators.subm b/crates/submilli-engine/tests/fixtures/asi_line_wrapped_operators.subm similarity index 100% rename from crates/interpreter/tests/fixtures/asi_line_wrapped_operators.subm rename to crates/submilli-engine/tests/fixtures/asi_line_wrapped_operators.subm diff --git a/crates/interpreter/tests/fixtures/asi_statement_ends_at_closing_brace.ts b/crates/submilli-engine/tests/fixtures/asi_statement_ends_at_closing_brace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_statement_ends_at_closing_brace.ts rename to crates/submilli-engine/tests/fixtures/asi_statement_ends_at_closing_brace.ts diff --git a/crates/interpreter/tests/fixtures/asi_template_substitution_wraps.ts b/crates/submilli-engine/tests/fixtures/asi_template_substitution_wraps.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_template_substitution_wraps.ts rename to crates/submilli-engine/tests/fixtures/asi_template_substitution_wraps.ts diff --git a/crates/interpreter/tests/fixtures/asi_type_members_in_brackets.ts b/crates/submilli-engine/tests/fixtures/asi_type_members_in_brackets.ts similarity index 100% rename from crates/interpreter/tests/fixtures/asi_type_members_in_brackets.ts rename to crates/submilli-engine/tests/fixtures/asi_type_members_in_brackets.ts diff --git a/crates/interpreter/tests/fixtures/assert_pass.subm b/crates/submilli-engine/tests/fixtures/assert_pass.subm similarity index 100% rename from crates/interpreter/tests/fixtures/assert_pass.subm rename to crates/submilli-engine/tests/fixtures/assert_pass.subm diff --git a/crates/interpreter/tests/fixtures/assert_throws_catchable.subm b/crates/submilli-engine/tests/fixtures/assert_throws_catchable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/assert_throws_catchable.subm rename to crates/submilli-engine/tests/fixtures/assert_throws_catchable.subm diff --git a/crates/interpreter/tests/fixtures/assignment_expression.ts b/crates/submilli-engine/tests/fixtures/assignment_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/assignment_expression.ts rename to crates/submilli-engine/tests/fixtures/assignment_expression.ts diff --git a/crates/interpreter/tests/fixtures/assignment_keeps_literal_types.ts b/crates/submilli-engine/tests/fixtures/assignment_keeps_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/assignment_keeps_literal_types.ts rename to crates/submilli-engine/tests/fixtures/assignment_keeps_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/assignment_narrows_to_declared_member.ts b/crates/submilli-engine/tests/fixtures/assignment_narrows_to_declared_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/assignment_narrows_to_declared_member.ts rename to crates/submilli-engine/tests/fixtures/assignment_narrows_to_declared_member.ts diff --git a/crates/interpreter/tests/fixtures/bare_return_in_inferred_closure.ts b/crates/submilli-engine/tests/fixtures/bare_return_in_inferred_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bare_return_in_inferred_closure.ts rename to crates/submilli-engine/tests/fixtures/bare_return_in_inferred_closure.ts diff --git a/crates/interpreter/tests/fixtures/bigint_arithmetic.subm b/crates/submilli-engine/tests/fixtures/bigint_arithmetic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_arithmetic.subm rename to crates/submilli-engine/tests/fixtures/bigint_arithmetic.subm diff --git a/crates/interpreter/tests/fixtures/bigint_compare.subm b/crates/submilli-engine/tests/fixtures/bigint_compare.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_compare.subm rename to crates/submilli-engine/tests/fixtures/bigint_compare.subm diff --git a/crates/interpreter/tests/fixtures/bigint_container_equality.subm b/crates/submilli-engine/tests/fixtures/bigint_container_equality.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_container_equality.subm rename to crates/submilli-engine/tests/fixtures/bigint_container_equality.subm diff --git a/crates/interpreter/tests/fixtures/bigint_conversions.subm b/crates/submilli-engine/tests/fixtures/bigint_conversions.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_conversions.subm rename to crates/submilli-engine/tests/fixtures/bigint_conversions.subm diff --git a/crates/interpreter/tests/fixtures/bigint_decimal_budget.ts b/crates/submilli-engine/tests/fixtures/bigint_decimal_budget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_decimal_budget.ts rename to crates/submilli-engine/tests/fixtures/bigint_decimal_budget.ts diff --git a/crates/interpreter/tests/fixtures/bigint_float_literal.subm b/crates/submilli-engine/tests/fixtures/bigint_float_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_float_literal.subm rename to crates/submilli-engine/tests/fixtures/bigint_float_literal.subm diff --git a/crates/interpreter/tests/fixtures/bigint_join.subm b/crates/submilli-engine/tests/fixtures/bigint_join.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_join.subm rename to crates/submilli-engine/tests/fixtures/bigint_join.subm diff --git a/crates/interpreter/tests/fixtures/bigint_large_literal.subm b/crates/submilli-engine/tests/fixtures/bigint_large_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_large_literal.subm rename to crates/submilli-engine/tests/fixtures/bigint_large_literal.subm diff --git a/crates/interpreter/tests/fixtures/bigint_literal_basic.subm b/crates/submilli-engine/tests/fixtures/bigint_literal_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_literal_basic.subm rename to crates/submilli-engine/tests/fixtures/bigint_literal_basic.subm diff --git a/crates/interpreter/tests/fixtures/bigint_literal_narrowing.ts b/crates/submilli-engine/tests/fixtures/bigint_literal_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_literal_narrowing.ts rename to crates/submilli-engine/tests/fixtures/bigint_literal_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/bigint_literal_types.ts b/crates/submilli-engine/tests/fixtures/bigint_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_literal_types.ts rename to crates/submilli-engine/tests/fixtures/bigint_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/bigint_namespace_typo.subm b/crates/submilli-engine/tests/fixtures/bigint_namespace_typo.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_namespace_typo.subm rename to crates/submilli-engine/tests/fixtures/bigint_namespace_typo.subm diff --git a/crates/interpreter/tests/fixtures/bigint_number_exact.ts b/crates/submilli-engine/tests/fixtures/bigint_number_exact.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_number_exact.ts rename to crates/submilli-engine/tests/fixtures/bigint_number_exact.ts diff --git a/crates/interpreter/tests/fixtures/bigint_plus_number.subm b/crates/submilli-engine/tests/fixtures/bigint_plus_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_plus_number.subm rename to crates/submilli-engine/tests/fixtures/bigint_plus_number.subm diff --git a/crates/interpreter/tests/fixtures/bigint_to_json.ts b/crates/submilli-engine/tests/fixtures/bigint_to_json.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_to_json.ts rename to crates/submilli-engine/tests/fixtures/bigint_to_json.ts diff --git a/crates/interpreter/tests/fixtures/bigint_to_string_radix.subm b/crates/submilli-engine/tests/fixtures/bigint_to_string_radix.subm similarity index 100% rename from crates/interpreter/tests/fixtures/bigint_to_string_radix.subm rename to crates/submilli-engine/tests/fixtures/bigint_to_string_radix.subm diff --git a/crates/interpreter/tests/fixtures/bind_void_call_value.ts b/crates/submilli-engine/tests/fixtures/bind_void_call_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bind_void_call_value.ts rename to crates/submilli-engine/tests/fixtures/bind_void_call_value.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/calls.ts b/crates/submilli-engine/tests/fixtures/binding_scope/calls.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/calls.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/calls.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/capture_block_shadow.ts b/crates/submilli-engine/tests/fixtures/binding_scope/capture_block_shadow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/capture_block_shadow.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/capture_block_shadow.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/captured_write.ts b/crates/submilli-engine/tests/fixtures/binding_scope/captured_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/captured_write.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/captured_write.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/early_assignment.ts b/crates/submilli-engine/tests/fixtures/binding_scope/early_assignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/early_assignment.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/early_assignment.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/early_namespace.ts b/crates/submilli-engine/tests/fixtures/binding_scope/early_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/early_namespace.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/early_namespace.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_shadow.ts b/crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_shadow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_shadow.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_shadow.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_tdz.ts b/crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_tdz.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_tdz.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/for_of_tdz.ts b/crates/submilli-engine/tests/fixtures/binding_scope/for_of_tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/for_of_tdz.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/for_of_tdz.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/hygiene.ts b/crates/submilli-engine/tests/fixtures/binding_scope/hygiene.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/hygiene.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/hygiene.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/hygiene_array.ts b/crates/submilli-engine/tests/fixtures/binding_scope/hygiene_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/hygiene_array.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/hygiene_array.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/hygiene_iterator.ts b/crates/submilli-engine/tests/fixtures/binding_scope/hygiene_iterator.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/hygiene_iterator.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/hygiene_iterator.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/intrinsic.ts b/crates/submilli-engine/tests/fixtures/binding_scope/intrinsic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/intrinsic.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/intrinsic.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/mutators.ts b/crates/submilli-engine/tests/fixtures/binding_scope/mutators.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/mutators.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/mutators.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/namespace.ts b/crates/submilli-engine/tests/fixtures/binding_scope/namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/namespace.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/namespace.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/parseint_required_arg.ts b/crates/submilli-engine/tests/fixtures/binding_scope/parseint_required_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/parseint_required_arg.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/parseint_required_arg.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/pattern_hygiene.ts b/crates/submilli-engine/tests/fixtures/binding_scope/pattern_hygiene.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/pattern_hygiene.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/pattern_hygiene.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare_catch.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_catch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare_catch.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare_catch.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare_let.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_let.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare_let.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare_let.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare_param.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_param.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare_param.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare_param.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare_pattern.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_pattern.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare_pattern.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare_pattern.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/redeclare_rest.ts b/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/redeclare_rest.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/redeclare_rest.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/self_initialization.ts b/crates/submilli-engine/tests/fixtures/binding_scope/self_initialization.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/self_initialization.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/self_initialization.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/shadowing.ts b/crates/submilli-engine/tests/fixtures/binding_scope/shadowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/shadowing.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/shadowing.ts diff --git a/crates/interpreter/tests/fixtures/binding_scope/tdz.ts b/crates/submilli-engine/tests/fixtures/binding_scope/tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/binding_scope/tdz.ts rename to crates/submilli-engine/tests/fixtures/binding_scope/tdz.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/asi.ts b/crates/submilli-engine/tests/fixtures/bitwise/asi.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/asi.ts rename to crates/submilli-engine/tests/fixtures/bitwise/asi.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/assignments.ts b/crates/submilli-engine/tests/fixtures/bitwise/assignments.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/assignments.ts rename to crates/submilli-engine/tests/fixtures/bitwise/assignments.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/bigints.ts b/crates/submilli-engine/tests/fixtures/bitwise/bigints.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/bigints.ts rename to crates/submilli-engine/tests/fixtures/bitwise/bigints.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/coercion.ts b/crates/submilli-engine/tests/fixtures/bitwise/coercion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/coercion.ts rename to crates/submilli-engine/tests/fixtures/bitwise/coercion.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/evaluation.ts b/crates/submilli-engine/tests/fixtures/bitwise/evaluation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/evaluation.ts rename to crates/submilli-engine/tests/fixtures/bitwise/evaluation.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/generics.ts b/crates/submilli-engine/tests/fixtures/bitwise/generics.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/generics.ts rename to crates/submilli-engine/tests/fixtures/bitwise/generics.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/invalid.ts b/crates/submilli-engine/tests/fixtures/bitwise/invalid.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/invalid.ts rename to crates/submilli-engine/tests/fixtures/bitwise/invalid.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/invalid_unary.ts b/crates/submilli-engine/tests/fixtures/bitwise/invalid_unary.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/invalid_unary.ts rename to crates/submilli-engine/tests/fixtures/bitwise/invalid_unary.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/live_values.ts b/crates/submilli-engine/tests/fixtures/bitwise/live_values.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/live_values.ts rename to crates/submilli-engine/tests/fixtures/bitwise/live_values.ts diff --git a/crates/interpreter/tests/fixtures/bitwise/numbers.ts b/crates/submilli-engine/tests/fixtures/bitwise/numbers.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bitwise/numbers.ts rename to crates/submilli-engine/tests/fixtures/bitwise/numbers.ts diff --git a/crates/interpreter/tests/fixtures/boolean_literal_types.ts b/crates/submilli-engine/tests/fixtures/boolean_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/boolean_literal_types.ts rename to crates/submilli-engine/tests/fixtures/boolean_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/boxed_primitive_vtables.ts b/crates/submilli-engine/tests/fixtures/boxed_primitive_vtables.ts similarity index 100% rename from crates/interpreter/tests/fixtures/boxed_primitive_vtables.ts rename to crates/submilli-engine/tests/fixtures/boxed_primitive_vtables.ts diff --git a/crates/interpreter/tests/fixtures/braceless_bodies_accepted.ts b/crates/submilli-engine/tests/fixtures/braceless_bodies_accepted.ts similarity index 100% rename from crates/interpreter/tests/fixtures/braceless_bodies_accepted.ts rename to crates/submilli-engine/tests/fixtures/braceless_bodies_accepted.ts diff --git a/crates/interpreter/tests/fixtures/braceless_control_bodies.subm b/crates/submilli-engine/tests/fixtures/braceless_control_bodies.subm similarity index 100% rename from crates/interpreter/tests/fixtures/braceless_control_bodies.subm rename to crates/submilli-engine/tests/fixtures/braceless_control_bodies.subm diff --git a/crates/interpreter/tests/fixtures/builtin_error.subm b/crates/submilli-engine/tests/fixtures/builtin_error.subm similarity index 100% rename from crates/interpreter/tests/fixtures/builtin_error.subm rename to crates/submilli-engine/tests/fixtures/builtin_error.subm diff --git a/crates/interpreter/tests/fixtures/bulk_string_and_byte_copies.ts b/crates/submilli-engine/tests/fixtures/bulk_string_and_byte_copies.ts similarity index 100% rename from crates/interpreter/tests/fixtures/bulk_string_and_byte_copies.ts rename to crates/submilli-engine/tests/fixtures/bulk_string_and_byte_copies.ts diff --git a/crates/interpreter/tests/fixtures/call_sig_number_from_string.subm b/crates/submilli-engine/tests/fixtures/call_sig_number_from_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/call_sig_number_from_string.subm rename to crates/submilli-engine/tests/fixtures/call_sig_number_from_string.subm diff --git a/crates/interpreter/tests/fixtures/call_sig_string_coercion.subm b/crates/submilli-engine/tests/fixtures/call_sig_string_coercion.subm similarity index 100% rename from crates/interpreter/tests/fixtures/call_sig_string_coercion.subm rename to crates/submilli-engine/tests/fixtures/call_sig_string_coercion.subm diff --git a/crates/interpreter/tests/fixtures/call_sig_user_interface.subm b/crates/submilli-engine/tests/fixtures/call_sig_user_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/call_sig_user_interface.subm rename to crates/submilli-engine/tests/fixtures/call_sig_user_interface.subm diff --git a/crates/interpreter/tests/fixtures/captured_let_same_frame_reassign.subm b/crates/submilli-engine/tests/fixtures/captured_let_same_frame_reassign.subm similarity index 100% rename from crates/interpreter/tests/fixtures/captured_let_same_frame_reassign.subm rename to crates/submilli-engine/tests/fixtures/captured_let_same_frame_reassign.subm diff --git a/crates/interpreter/tests/fixtures/cast_and_spread_object_literals.ts b/crates/submilli-engine/tests/fixtures/cast_and_spread_object_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cast_and_spread_object_literals.ts rename to crates/submilli-engine/tests/fixtures/cast_and_spread_object_literals.ts diff --git a/crates/interpreter/tests/fixtures/cast_rest_function_to_fixed_arity.ts b/crates/submilli-engine/tests/fixtures/cast_rest_function_to_fixed_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cast_rest_function_to_fixed_arity.ts rename to crates/submilli-engine/tests/fixtures/cast_rest_function_to_fixed_arity.ts diff --git a/crates/interpreter/tests/fixtures/cast_self_nominal_interface.ts b/crates/submilli-engine/tests/fixtures/cast_self_nominal_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cast_self_nominal_interface.ts rename to crates/submilli-engine/tests/fixtures/cast_self_nominal_interface.ts diff --git a/crates/interpreter/tests/fixtures/cast_to_union_member_overlap.ts b/crates/submilli-engine/tests/fixtures/cast_to_union_member_overlap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cast_to_union_member_overlap.ts rename to crates/submilli-engine/tests/fixtures/cast_to_union_member_overlap.ts diff --git a/crates/interpreter/tests/fixtures/cast_void_adapter_to_value_function.ts b/crates/submilli-engine/tests/fixtures/cast_void_adapter_to_value_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cast_void_adapter_to_value_function.ts rename to crates/submilli-engine/tests/fixtures/cast_void_adapter_to_value_function.ts diff --git a/crates/interpreter/tests/fixtures/casts/as_array_element_check.subm b/crates/submilli-engine/tests/fixtures/casts/as_array_element_check.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_array_element_check.subm rename to crates/submilli-engine/tests/fixtures/casts/as_array_element_check.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_chain_round_trip.subm b/crates/submilli-engine/tests/fixtures/casts/as_chain_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_chain_round_trip.subm rename to crates/submilli-engine/tests/fixtures/casts/as_chain_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_enum_target.ts b/crates/submilli-engine/tests/fixtures/casts/as_enum_target.ts similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_enum_target.ts rename to crates/submilli-engine/tests/fixtures/casts/as_enum_target.ts diff --git a/crates/interpreter/tests/fixtures/casts/as_interface_non_object_throws.subm b/crates/submilli-engine/tests/fixtures/casts/as_interface_non_object_throws.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_interface_non_object_throws.subm rename to crates/submilli-engine/tests/fixtures/casts/as_interface_non_object_throws.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_nested_and_optional.subm b/crates/submilli-engine/tests/fixtures/casts/as_nested_and_optional.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_nested_and_optional.subm rename to crates/submilli-engine/tests/fixtures/casts/as_nested_and_optional.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_number_passthrough.subm b/crates/submilli-engine/tests/fixtures/casts/as_number_passthrough.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_number_passthrough.subm rename to crates/submilli-engine/tests/fixtures/casts/as_number_passthrough.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_object_literal_field.subm b/crates/submilli-engine/tests/fixtures/casts/as_object_literal_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_object_literal_field.subm rename to crates/submilli-engine/tests/fixtures/casts/as_object_literal_field.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_proven_upcast_no_check.subm b/crates/submilli-engine/tests/fixtures/casts/as_proven_upcast_no_check.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_proven_upcast_no_check.subm rename to crates/submilli-engine/tests/fixtures/casts/as_proven_upcast_no_check.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_recursive_object.subm b/crates/submilli-engine/tests/fixtures/casts/as_recursive_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_recursive_object.subm rename to crates/submilli-engine/tests/fixtures/casts/as_recursive_object.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_recursive_union.subm b/crates/submilli-engine/tests/fixtures/casts/as_recursive_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_recursive_union.subm rename to crates/submilli-engine/tests/fixtures/casts/as_recursive_union.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_string_passthrough.subm b/crates/submilli-engine/tests/fixtures/casts/as_string_passthrough.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_string_passthrough.subm rename to crates/submilli-engine/tests/fixtures/casts/as_string_passthrough.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_union_to_member.subm b/crates/submilli-engine/tests/fixtures/casts/as_union_to_member.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_union_to_member.subm rename to crates/submilli-engine/tests/fixtures/casts/as_union_to_member.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_unknown_to_interface.subm b/crates/submilli-engine/tests/fixtures/casts/as_unknown_to_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_unknown_to_interface.subm rename to crates/submilli-engine/tests/fixtures/casts/as_unknown_to_interface.subm diff --git a/crates/interpreter/tests/fixtures/casts/as_unknown_to_object_shape.subm b/crates/submilli-engine/tests/fixtures/casts/as_unknown_to_object_shape.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/as_unknown_to_object_shape.subm rename to crates/submilli-engine/tests/fixtures/casts/as_unknown_to_object_shape.subm diff --git a/crates/interpreter/tests/fixtures/casts/expect_error_incompatible_static_cast.subm b/crates/submilli-engine/tests/fixtures/casts/expect_error_incompatible_static_cast.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/expect_error_incompatible_static_cast.subm rename to crates/submilli-engine/tests/fixtures/casts/expect_error_incompatible_static_cast.subm diff --git a/crates/interpreter/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm b/crates/submilli-engine/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm rename to crates/submilli-engine/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm diff --git a/crates/interpreter/tests/fixtures/casts/issue_905_paths.ts b/crates/submilli-engine/tests/fixtures/casts/issue_905_paths.ts similarity index 100% rename from crates/interpreter/tests/fixtures/casts/issue_905_paths.ts rename to crates/submilli-engine/tests/fixtures/casts/issue_905_paths.ts diff --git a/crates/interpreter/tests/fixtures/casts/issue_982_disjoint.ts b/crates/submilli-engine/tests/fixtures/casts/issue_982_disjoint.ts similarity index 100% rename from crates/interpreter/tests/fixtures/casts/issue_982_disjoint.ts rename to crates/submilli-engine/tests/fixtures/casts/issue_982_disjoint.ts diff --git a/crates/interpreter/tests/fixtures/casts/issue_982_literal_overlap.ts b/crates/submilli-engine/tests/fixtures/casts/issue_982_literal_overlap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/casts/issue_982_literal_overlap.ts rename to crates/submilli-engine/tests/fixtures/casts/issue_982_literal_overlap.ts diff --git a/crates/interpreter/tests/fixtures/casts/uint8array_is_as.ts b/crates/submilli-engine/tests/fixtures/casts/uint8array_is_as.ts similarity index 100% rename from crates/interpreter/tests/fixtures/casts/uint8array_is_as.ts rename to crates/submilli-engine/tests/fixtures/casts/uint8array_is_as.ts diff --git a/crates/interpreter/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm b/crates/submilli-engine/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm similarity index 100% rename from crates/interpreter/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm rename to crates/submilli-engine/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm diff --git a/crates/interpreter/tests/fixtures/chain_generic_method_reference.ts b/crates/submilli-engine/tests/fixtures/chain_generic_method_reference.ts similarity index 100% rename from crates/interpreter/tests/fixtures/chain_generic_method_reference.ts rename to crates/submilli-engine/tests/fixtures/chain_generic_method_reference.ts diff --git a/crates/interpreter/tests/fixtures/chain_non_generic_optional_calls.ts b/crates/submilli-engine/tests/fixtures/chain_non_generic_optional_calls.ts similarity index 100% rename from crates/interpreter/tests/fixtures/chain_non_generic_optional_calls.ts rename to crates/submilli-engine/tests/fixtures/chain_non_generic_optional_calls.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_destructure/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_destructure/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_destructure/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_destructure/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_destructured_param/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_destructured_param/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_destructured_param/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_destructured_param/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_for_of/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_for_of/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_for_of/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_for_of/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_package_value/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_package_value/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_package_value/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_package_value/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_primitives/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_primitives/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_primitives/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_primitives/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_response_mapping/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_response_mapping/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_response_mapping/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_response_mapping/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/clean_unguarded/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/clean_unguarded/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/clean_unguarded/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/clean_unguarded/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_argument/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_argument/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_argument/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_argument/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_array_literal/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_array_literal/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_array_literal/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_array_literal/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_callback/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_callback/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_callback/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_callback/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_captured/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_captured/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_captured/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_captured/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_context/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_context/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_context/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_context/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_merged/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_merged/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_merged/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_merged/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_method_call/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_method_call/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_method_call/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_method_call/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_mutation/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_mutation/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_mutation/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_mutation/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_operand/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_operand/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_operand/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_operand/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_returned/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_returned/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_returned/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_returned/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_spread/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_spread/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_spread/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_spread/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_stored/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_stored/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_stored/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_stored/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/escape_thrown/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/escape_thrown/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/escape_thrown/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/escape_thrown/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_closure/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_closure/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_closure/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_closure/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/internal.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/internal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/internal.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/internal.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_members/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_members/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_members/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_members/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_module_level/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_module_level/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_module_level/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_module_level/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_private_helper/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_private_helper/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_private_helper/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_private_helper/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_reexport/internal.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/internal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_reexport/internal.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/internal.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_reexport/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_reexport/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_iteration/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_iteration/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_iteration/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_iteration/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_alias/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_alias/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_alias/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_alias/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_control/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_control/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_control/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_control/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_loop/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_loop/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_loop/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_loop/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts diff --git a/crates/interpreter/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts b/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts rename to crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts diff --git a/crates/interpreter/tests/fixtures/class_chain_at_limit.ts b/crates/submilli-engine/tests/fixtures/class_chain_at_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/class_chain_at_limit.ts rename to crates/submilli-engine/tests/fixtures/class_chain_at_limit.ts diff --git a/crates/interpreter/tests/fixtures/class_never_field_collection_key.ts b/crates/submilli-engine/tests/fixtures/class_never_field_collection_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/class_never_field_collection_key.ts rename to crates/submilli-engine/tests/fixtures/class_never_field_collection_key.ts diff --git a/crates/interpreter/tests/fixtures/class_to_string_field.ts b/crates/submilli-engine/tests/fixtures/class_to_string_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/class_to_string_field.ts rename to crates/submilli-engine/tests/fixtures/class_to_string_field.ts diff --git a/crates/interpreter/tests/fixtures/class_used_before_declaration_throws.ts b/crates/submilli-engine/tests/fixtures/class_used_before_declaration_throws.ts similarity index 100% rename from crates/interpreter/tests/fixtures/class_used_before_declaration_throws.ts rename to crates/submilli-engine/tests/fixtures/class_used_before_declaration_throws.ts diff --git a/crates/interpreter/tests/fixtures/classes/abstract_member.ts b/crates/submilli-engine/tests/fixtures/classes/abstract_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/abstract_member.ts rename to crates/submilli-engine/tests/fixtures/classes/abstract_member.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/accessor_basic.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_basic.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_basic.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_cross_package/geo/lib.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/geo/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_cross_package/geo/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/geo/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/accessor_different_types.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_different_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_different_types.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_different_types.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_half_inherited.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_half_inherited.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_half_inherited.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_half_inherited.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_implements_readonly.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_implements_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_implements_readonly.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_implements_readonly.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_override.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_override.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_override.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_override.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_readonly.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_readonly.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_readonly.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_redeclared_compatibly.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_redeclared_compatibly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_redeclared_compatibly.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_redeclared_compatibly.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_via_interface.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_via_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_via_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_via_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/accessor_write_only.ts b/crates/submilli-engine/tests/fixtures/classes/accessor_write_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/accessor_write_only.ts rename to crates/submilli-engine/tests/fixtures/classes/accessor_write_only.ts diff --git a/crates/interpreter/tests/fixtures/classes/bad_override.ts b/crates/submilli-engine/tests/fixtures/classes/bad_override.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/bad_override.ts rename to crates/submilli-engine/tests/fixtures/classes/bad_override.ts diff --git a/crates/interpreter/tests/fixtures/classes/captured_class_binding_boxed.ts b/crates/submilli-engine/tests/fixtures/classes/captured_class_binding_boxed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/captured_class_binding_boxed.ts rename to crates/submilli-engine/tests/fixtures/classes/captured_class_binding_boxed.ts diff --git a/crates/interpreter/tests/fixtures/classes/cast_accessor_conformance.ts b/crates/submilli-engine/tests/fixtures/classes/cast_accessor_conformance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/cast_accessor_conformance.ts rename to crates/submilli-engine/tests/fixtures/classes/cast_accessor_conformance.ts diff --git a/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts b/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/catch_generic_error_bare.ts b/crates/submilli-engine/tests/fixtures/classes/catch_generic_error_bare.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/catch_generic_error_bare.ts rename to crates/submilli-engine/tests/fixtures/classes/catch_generic_error_bare.ts diff --git a/crates/interpreter/tests/fixtures/classes/closure_captures_this.ts b/crates/submilli-engine/tests/fixtures/classes/closure_captures_this.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/closure_captures_this.ts rename to crates/submilli-engine/tests/fixtures/classes/closure_captures_this.ts diff --git a/crates/interpreter/tests/fixtures/classes/closure_in_member_bodies.ts b/crates/submilli-engine/tests/fixtures/classes/closure_in_member_bodies.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/closure_in_member_bodies.ts rename to crates/submilli-engine/tests/fixtures/classes/closure_in_member_bodies.ts diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts b/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts b/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_field.ts b/crates/submilli-engine/tests/fixtures/classes/compound_assign_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_field.ts rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/compound_assign_generic_field.ts b/crates/submilli-engine/tests/fixtures/classes/compound_assign_generic_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/compound_assign_generic_field.ts rename to crates/submilli-engine/tests/fixtures/classes/compound_assign_generic_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/construct_and_read_fields.ts b/crates/submilli-engine/tests/fixtures/classes/construct_and_read_fields.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/construct_and_read_fields.ts rename to crates/submilli-engine/tests/fixtures/classes/construct_and_read_fields.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/ctor_default_and_rest.ts b/crates/submilli-engine/tests/fixtures/classes/ctor_default_and_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_default_and_rest.ts rename to crates/submilli-engine/tests/fixtures/classes/ctor_default_and_rest.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/dynamic_dispatch.ts b/crates/submilli-engine/tests/fixtures/classes/dynamic_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/dynamic_dispatch.ts rename to crates/submilli-engine/tests/fixtures/classes/dynamic_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_cross_package/labeled/lib.ts b/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/labeled/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_cross_package/labeled/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_cross_package/labeled/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/equals_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/equals_cross_package/points/lib.ts b/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/points/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_cross_package/points/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_cross_package/points/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_error.ts b/crates/submilli-engine/tests/fixtures/classes/equals_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_error.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_error.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_nullable_field.ts b/crates/submilli-engine/tests/fixtures/classes/equals_nullable_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_nullable_field.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_nullable_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_sibling_same_shape.ts b/crates/submilli-engine/tests/fixtures/classes/equals_sibling_same_shape.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_sibling_same_shape.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_sibling_same_shape.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_structural_fields.ts b/crates/submilli-engine/tests/fixtures/classes/equals_structural_fields.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_structural_fields.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_structural_fields.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_subclass_vs_base.ts b/crates/submilli-engine/tests/fixtures/classes/equals_subclass_vs_base.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_subclass_vs_base.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_subclass_vs_base.ts diff --git a/crates/interpreter/tests/fixtures/classes/equals_vs_other_runtime_types.ts b/crates/submilli-engine/tests/fixtures/classes/equals_vs_other_runtime_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/equals_vs_other_runtime_types.ts rename to crates/submilli-engine/tests/fixtures/classes/equals_vs_other_runtime_types.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_catch_closure_capture.ts b/crates/submilli-engine/tests/fixtures/classes/error_catch_closure_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_catch_closure_capture.ts rename to crates/submilli-engine/tests/fixtures/classes/error_catch_closure_capture.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_field_mutation.ts b/crates/submilli-engine/tests/fixtures/classes/error_field_mutation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_field_mutation.ts rename to crates/submilli-engine/tests/fixtures/classes/error_field_mutation.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_basic.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_basic.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_basic.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_throw_catch.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_throw_catch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_throw_catch.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_throw_catch.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch_finally.ts b/crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch_finally.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch_finally.ts rename to crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch_finally.ts diff --git a/crates/interpreter/tests/fixtures/classes/error_union_null.ts b/crates/submilli-engine/tests/fixtures/classes/error_union_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/error_union_null.ts rename to crates/submilli-engine/tests/fixtures/classes/error_union_null.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_accessor_half_guards.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_half_guards.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_accessor_half_guards.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_half_guards.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_missing_static.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_missing_static.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_missing_static.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_missing_static.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_method.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_static_method.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_method.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_readonly.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_static_readonly.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_readonly.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_assign_to_method.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_to_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_assign_to_method.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_assign_to_method.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_bare_class_value.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_bare_class_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_bare_class_value.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_bare_class_value.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_catch_generic_args.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_generic_args.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_catch_generic_args.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_catch_generic_args.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_catch_non_error.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_non_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_catch_non_error.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_catch_non_error.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_catch_unrelated_class.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_unrelated_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_catch_unrelated_class.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_catch_unrelated_class.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_compound_assign_readonly.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_compound_assign_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_compound_assign_readonly.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_compound_assign_readonly.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_wider.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_wider.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_wider.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_wider.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_field_used_before_initialization.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_field_used_before_initialization.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_field_used_before_initialization.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_field_used_before_initialization.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_interface.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_implements_missing_member.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_missing_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_implements_missing_member.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_implements_missing_member.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_arity.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_arity.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_arity.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_signature.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_signature.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_signature.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_instance_on_class.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_instance_on_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_instance_on_class.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_instance_on_class.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_interface.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_instanceof_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_unrelated.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_unrelated.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_instanceof_unrelated.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_unrelated.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_member_closures_and_switches.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_member_closures_and_switches.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_member_closures_and_switches.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_member_closures_and_switches.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_member_missing_return.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_member_missing_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_member_missing_return.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_member_missing_return.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_member_unreachable_code.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_member_unreachable_code.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_member_unreachable_code.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_member_unreachable_code.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_optional_vs_required_member.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_optional_vs_required_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_optional_vs_required_member.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_optional_vs_required_member.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_override_fewer_params.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_override_fewer_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_override_fewer_params.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_override_fewer_params.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_readonly.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_readonly.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_readonly.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_string.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_string.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_string.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_read_write_only.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_read_write_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_read_write_only.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_read_write_only.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_accessor.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_accessor.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_accessor.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_class_generic.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_class_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_class_generic.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_class_generic.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_constructor.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_constructor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_constructor.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_constructor.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_field_no_init.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_field_no_init.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_field_no_init.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_field_no_init.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_instance_name_collision.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_instance_name_collision.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_instance_name_collision.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_instance_name_collision.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance_help.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance_help.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance_help.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance_help.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_optional_field.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_optional_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_optional_field.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_optional_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_this.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_this.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_this.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_this.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_subclass_shape_dump.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_subclass_shape_dump.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_subclass_shape_dump.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_subclass_shape_dump.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_to_string_signature.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_to_string_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_to_string_signature.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_to_string_signature.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_type_beats_mutability.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_type_beats_mutability.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_type_beats_mutability.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_type_beats_mutability.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_field.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_field.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts diff --git a/crates/interpreter/tests/fixtures/classes/expect_error_unknown_static.ts b/crates/submilli-engine/tests/fixtures/classes/expect_error_unknown_static.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/expect_error_unknown_static.ts rename to crates/submilli-engine/tests/fixtures/classes/expect_error_unknown_static.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_module/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_module/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_module/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_module/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_module/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_module/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/animal.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/animal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/animal.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/animal.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/lib.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package/animals/lib.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/animals/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package/animals/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package/animals/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package/dogs/lib.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/dogs/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package/dogs/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package/dogs/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package_private/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cross_package_private/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/extends_cycle.ts b/crates/submilli-engine/tests/fixtures/classes/extends_cycle.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_cycle.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_cycle.ts diff --git a/crates/interpreter/tests/fixtures/classes/extends_non_class.ts b/crates/submilli-engine/tests/fixtures/classes/extends_non_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/extends_non_class.ts rename to crates/submilli-engine/tests/fixtures/classes/extends_non_class.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_init_inherited.ts b/crates/submilli-engine/tests/fixtures/classes/field_init_inherited.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_init_inherited.ts rename to crates/submilli-engine/tests/fixtures/classes/field_init_inherited.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_initializers.ts b/crates/submilli-engine/tests/fixtures/classes/field_initializers.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_initializers.ts rename to crates/submilli-engine/tests/fixtures/classes/field_initializers.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_all_reads.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_all_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_all_reads.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_all_reads.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_constructor.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_constructor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_constructor.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_constructor.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_enums.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_enums.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_enums.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_enums.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_erased_method.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_erased_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_erased_method.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_erased_method.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_box.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_box.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_box.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_box.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_context.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_context.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_context.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_context.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_host_info.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_host_info.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_host_info.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_host_info.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_union_interface.ts b/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_union_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_narrowing_guard_union_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_union_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_in_subclass.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_in_subclass.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_in_subclass.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_in_subclass.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/implements_aliased_interface.ts b/crates/submilli-engine/tests/fixtures/classes/implements_aliased_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_aliased_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_aliased_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_accessor.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_accessor.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_accessor.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_empty_subclass.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_empty_subclass.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_empty_subclass.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_empty_subclass.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_generic_base.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_generic_base.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_generic_base.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_generic_base.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_partial_override.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_partial_override.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_partial_override.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_partial_override.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts b/crates/submilli-engine/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_interface.ts b/crates/submilli-engine/tests/fixtures/classes/implements_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/implements_via_later_declared_parent.ts b/crates/submilli-engine/tests/fixtures/classes/implements_via_later_declared_parent.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implements_via_later_declared_parent.ts rename to crates/submilli-engine/tests/fixtures/classes/implements_via_later_declared_parent.ts diff --git a/crates/interpreter/tests/fixtures/classes/implicit_ctor.ts b/crates/submilli-engine/tests/fixtures/classes/implicit_ctor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/implicit_ctor.ts rename to crates/submilli-engine/tests/fixtures/classes/implicit_ctor.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_module/animals.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/animals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_module/animals.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/animals.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_module/lib.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_module/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_error_chain.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_error_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_error_chain.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_error_chain.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_narrow.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_narrow.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_narrow.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_negative.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_negative.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_negative.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_negative.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_sibling_same_shape.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_sibling_same_shape.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_sibling_same_shape.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_sibling_same_shape.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_generic.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_generic.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_generic.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_host_built.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_host_built.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_host_built.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_host_built.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_narrow.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_uint8array_narrow.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_narrow.ts diff --git a/crates/interpreter/tests/fixtures/classes/instanceof_unknown_lhs.ts b/crates/submilli-engine/tests/fixtures/classes/instanceof_unknown_lhs.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/instanceof_unknown_lhs.ts rename to crates/submilli-engine/tests/fixtures/classes/instanceof_unknown_lhs.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927_argument_order.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927_argument_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927_argument_order.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927_argument_order.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927_cycle.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927_cycle.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927_cycle.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927_cycle.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927_fixed_cycle.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927_fixed_cycle.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927_fixed_cycle.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927_fixed_cycle.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927_interface.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_927_union_cycle.ts b/crates/submilli-engine/tests/fixtures/classes/issue_927_union_cycle.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_927_union_cycle.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_927_union_cycle.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_967_checked_return_abi.ts b/crates/submilli-engine/tests/fixtures/classes/issue_967_checked_return_abi.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_967_checked_return_abi.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_967_checked_return_abi.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_967_default_interface.ts b/crates/submilli-engine/tests/fixtures/classes/issue_967_default_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_967_default_interface.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_967_default_interface.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_967_required.ts b/crates/submilli-engine/tests/fixtures/classes/issue_967_required.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_967_required.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_967_required.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_967_structural_defaults.ts b/crates/submilli-engine/tests/fixtures/classes/issue_967_structural_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_967_structural_defaults.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_967_structural_defaults.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_967_wrong_parameter.ts b/crates/submilli-engine/tests/fixtures/classes/issue_967_wrong_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_967_wrong_parameter.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_967_wrong_parameter.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_973_shorthand_boundary.ts b/crates/submilli-engine/tests/fixtures/classes/issue_973_shorthand_boundary.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_973_shorthand_boundary.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_973_shorthand_boundary.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_987_inline_object.ts b/crates/submilli-engine/tests/fixtures/classes/issue_987_inline_object.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_987_inline_object.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_987_inline_object.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_987_private.ts b/crates/submilli-engine/tests/fixtures/classes/issue_987_private.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_987_private.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_987_private.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_987_setter_only.ts b/crates/submilli-engine/tests/fixtures/classes/issue_987_setter_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_987_setter_only.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_987_setter_only.ts diff --git a/crates/interpreter/tests/fixtures/classes/issue_987_weak_target.ts b/crates/submilli-engine/tests/fixtures/classes/issue_987_weak_target.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/issue_987_weak_target.ts rename to crates/submilli-engine/tests/fixtures/classes/issue_987_weak_target.ts diff --git a/crates/interpreter/tests/fixtures/classes/json_inherited_private/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/json_inherited_private/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/json_inherited_private/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/json_inherited_private/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/json_inherited_private/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/json_inherited_private/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/json_inherited_private/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/json_inherited_private/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/json_inherited_private/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/json_public_properties.ts b/crates/submilli-engine/tests/fixtures/classes/json_public_properties.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/json_public_properties.ts rename to crates/submilli-engine/tests/fixtures/classes/json_public_properties.ts diff --git a/crates/interpreter/tests/fixtures/classes/map_set_class_keys.ts b/crates/submilli-engine/tests/fixtures/classes/map_set_class_keys.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/map_set_class_keys.ts rename to crates/submilli-engine/tests/fixtures/classes/map_set_class_keys.ts diff --git a/crates/interpreter/tests/fixtures/classes/method_dispatch.ts b/crates/submilli-engine/tests/fixtures/classes/method_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/method_dispatch.ts rename to crates/submilli-engine/tests/fixtures/classes/method_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/method_rewritten_through_alias.ts b/crates/submilli-engine/tests/fixtures/classes/method_rewritten_through_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/method_rewritten_through_alias.ts rename to crates/submilli-engine/tests/fixtures/classes/method_rewritten_through_alias.ts diff --git a/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts b/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts b/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/object_literal_in_member_bodies.ts b/crates/submilli-engine/tests/fixtures/classes/object_literal_in_member_bodies.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/object_literal_in_member_bodies.ts rename to crates/submilli-engine/tests/fixtures/classes/object_literal_in_member_bodies.ts diff --git a/crates/interpreter/tests/fixtures/classes/overridden_defaults.ts b/crates/submilli-engine/tests/fixtures/classes/overridden_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/overridden_defaults.ts rename to crates/submilli-engine/tests/fixtures/classes/overridden_defaults.ts diff --git a/crates/interpreter/tests/fixtures/classes/param_properties.ts b/crates/submilli-engine/tests/fixtures/classes/param_properties.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/param_properties.ts rename to crates/submilli-engine/tests/fixtures/classes/param_properties.ts diff --git a/crates/interpreter/tests/fixtures/classes/permission_denied_error_builtin.ts b/crates/submilli-engine/tests/fixtures/classes/permission_denied_error_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/permission_denied_error_builtin.ts rename to crates/submilli-engine/tests/fixtures/classes/permission_denied_error_builtin.ts diff --git a/crates/interpreter/tests/fixtures/classes/postfix_field_expression.ts b/crates/submilli-engine/tests/fixtures/classes/postfix_field_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/postfix_field_expression.ts rename to crates/submilli-engine/tests/fixtures/classes/postfix_field_expression.ts diff --git a/crates/interpreter/tests/fixtures/classes/private_constructor_packages/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/private_constructor_packages/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/private_constructor_packages/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/private_constructor_packages/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts b/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/private_cross_module/animal.ts b/crates/submilli-engine/tests/fixtures/classes/private_cross_module/animal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/private_cross_module/animal.ts rename to crates/submilli-engine/tests/fixtures/classes/private_cross_module/animal.ts diff --git a/crates/interpreter/tests/fixtures/classes/private_cross_module/lib.ts b/crates/submilli-engine/tests/fixtures/classes/private_cross_module/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/private_cross_module/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/private_cross_module/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/protected_member.ts b/crates/submilli-engine/tests/fixtures/classes/protected_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/protected_member.ts rename to crates/submilli-engine/tests/fixtures/classes/protected_member.ts diff --git a/crates/interpreter/tests/fixtures/classes/quota_exceeded_error.ts b/crates/submilli-engine/tests/fixtures/classes/quota_exceeded_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/quota_exceeded_error.ts rename to crates/submilli-engine/tests/fixtures/classes/quota_exceeded_error.ts diff --git a/crates/interpreter/tests/fixtures/classes/range_error_builtin.ts b/crates/submilli-engine/tests/fixtures/classes/range_error_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/range_error_builtin.ts rename to crates/submilli-engine/tests/fixtures/classes/range_error_builtin.ts diff --git a/crates/interpreter/tests/fixtures/classes/range_error_host_throws.ts b/crates/submilli-engine/tests/fixtures/classes/range_error_host_throws.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/range_error_host_throws.ts rename to crates/submilli-engine/tests/fixtures/classes/range_error_host_throws.ts diff --git a/crates/interpreter/tests/fixtures/classes/readonly_write_outside_ctor.ts b/crates/submilli-engine/tests/fixtures/classes/readonly_write_outside_ctor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/readonly_write_outside_ctor.ts rename to crates/submilli-engine/tests/fixtures/classes/readonly_write_outside_ctor.ts diff --git a/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts b/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts b/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/setter_assignment_as_value.ts b/crates/submilli-engine/tests/fixtures/classes/setter_assignment_as_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/setter_assignment_as_value.ts rename to crates/submilli-engine/tests/fixtures/classes/setter_assignment_as_value.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_and_instance_same_name.ts b/crates/submilli-engine/tests/fixtures/classes/static_and_instance_same_name.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_and_instance_same_name.ts rename to crates/submilli-engine/tests/fixtures/classes/static_and_instance_same_name.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_classref_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/static_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/static_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/static_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_cross_package/mathx/lib.ts b/crates/submilli-engine/tests/fixtures/classes/static_cross_package/mathx/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_cross_package/mathx/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/static_cross_package/mathx/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/static_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/static_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/static_generic_method.ts b/crates/submilli-engine/tests/fixtures/classes/static_generic_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_generic_method.ts rename to crates/submilli-engine/tests/fixtures/classes/static_generic_method.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_inheritance.ts b/crates/submilli-engine/tests/fixtures/classes/static_inheritance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_inheritance.ts rename to crates/submilli-engine/tests/fixtures/classes/static_inheritance.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_instance_name_collision.ts b/crates/submilli-engine/tests/fixtures/classes/static_instance_name_collision.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_instance_name_collision.ts rename to crates/submilli-engine/tests/fixtures/classes/static_instance_name_collision.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_members_do_not_redeclare.ts b/crates/submilli-engine/tests/fixtures/classes/static_members_do_not_redeclare.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_members_do_not_redeclare.ts rename to crates/submilli-engine/tests/fixtures/classes/static_members_do_not_redeclare.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_method_as_value.ts b/crates/submilli-engine/tests/fixtures/classes/static_method_as_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_method_as_value.ts rename to crates/submilli-engine/tests/fixtures/classes/static_method_as_value.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_method_basic.ts b/crates/submilli-engine/tests/fixtures/classes/static_method_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_method_basic.ts rename to crates/submilli-engine/tests/fixtures/classes/static_method_basic.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_assign.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_assign.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_assign.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_assign.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_field.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_field.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_inherited_write.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_inherited_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_inherited_write.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_inherited_write.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_postfix.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_postfix.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_postfix.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_postfix.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_mutable_private.ts b/crates/submilli-engine/tests/fixtures/classes/static_mutable_private.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_mutable_private.ts rename to crates/submilli-engine/tests/fixtures/classes/static_mutable_private.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_private.ts b/crates/submilli-engine/tests/fixtures/classes/static_private.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_private.ts rename to crates/submilli-engine/tests/fixtures/classes/static_private.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_readonly_field.ts b/crates/submilli-engine/tests/fixtures/classes/static_readonly_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_readonly_field.ts rename to crates/submilli-engine/tests/fixtures/classes/static_readonly_field.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts b/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/super_chain.ts b/crates/submilli-engine/tests/fixtures/classes/super_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/super_chain.ts rename to crates/submilli-engine/tests/fixtures/classes/super_chain.ts diff --git a/crates/interpreter/tests/fixtures/classes/super_ctor_field_init.ts b/crates/submilli-engine/tests/fixtures/classes/super_ctor_field_init.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/super_ctor_field_init.ts rename to crates/submilli-engine/tests/fixtures/classes/super_ctor_field_init.ts diff --git a/crates/interpreter/tests/fixtures/classes/super_method_override.ts b/crates/submilli-engine/tests/fixtures/classes/super_method_override.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/super_method_override.ts rename to crates/submilli-engine/tests/fixtures/classes/super_method_override.ts diff --git a/crates/interpreter/tests/fixtures/classes/syntax_error_builtin.ts b/crates/submilli-engine/tests/fixtures/classes/syntax_error_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/syntax_error_builtin.ts rename to crates/submilli-engine/tests/fixtures/classes/syntax_error_builtin.ts diff --git a/crates/interpreter/tests/fixtures/classes/this_in_field_initializer.ts b/crates/submilli-engine/tests/fixtures/classes/this_in_field_initializer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/this_in_field_initializer.ts rename to crates/submilli-engine/tests/fixtures/classes/this_in_field_initializer.ts diff --git a/crates/interpreter/tests/fixtures/classes/this_outside_method.ts b/crates/submilli-engine/tests/fixtures/classes/this_outside_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/this_outside_method.ts rename to crates/submilli-engine/tests/fixtures/classes/this_outside_method.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/type_error_builtin.ts b/crates/submilli-engine/tests/fixtures/classes/type_error_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/type_error_builtin.ts rename to crates/submilli-engine/tests/fixtures/classes/type_error_builtin.ts diff --git a/crates/interpreter/tests/fixtures/classes/type_error_host_thrown.ts b/crates/submilli-engine/tests/fixtures/classes/type_error_host_thrown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/type_error_host_thrown.ts rename to crates/submilli-engine/tests/fixtures/classes/type_error_host_thrown.ts diff --git a/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts b/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/undefined_reference_error.ts b/crates/submilli-engine/tests/fixtures/classes/undefined_reference_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/undefined_reference_error.ts rename to crates/submilli-engine/tests/fixtures/classes/undefined_reference_error.ts diff --git a/crates/interpreter/tests/fixtures/classes/universal_to_json.ts b/crates/submilli-engine/tests/fixtures/classes/universal_to_json.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/universal_to_json.ts rename to crates/submilli-engine/tests/fixtures/classes/universal_to_json.ts diff --git a/crates/interpreter/tests/fixtures/classes/universal_to_string.ts b/crates/submilli-engine/tests/fixtures/classes/universal_to_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/universal_to_string.ts rename to crates/submilli-engine/tests/fixtures/classes/universal_to_string.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts b/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts b/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts b/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/closure_captures_class_union.ts b/crates/submilli-engine/tests/fixtures/closure_captures_class_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_captures_class_union.ts rename to crates/submilli-engine/tests/fixtures/closure_captures_class_union.ts diff --git a/crates/interpreter/tests/fixtures/closure_coercion_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_coercion_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/closure_coercion_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_coercion_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/closure_coercion_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/closure_coercion_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/closure_counter.subm b/crates/submilli-engine/tests/fixtures/closure_counter.subm similarity index 100% rename from crates/interpreter/tests/fixtures/closure_counter.subm rename to crates/submilli-engine/tests/fixtures/closure_counter.subm diff --git a/crates/interpreter/tests/fixtures/closure_nullable_return.ts b/crates/submilli-engine/tests/fixtures/closure_nullable_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_nullable_return.ts rename to crates/submilli-engine/tests/fixtures/closure_nullable_return.ts diff --git a/crates/interpreter/tests/fixtures/closure_reads_later_module_variable.ts b/crates/submilli-engine/tests/fixtures/closure_reads_later_module_variable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_reads_later_module_variable.ts rename to crates/submilli-engine/tests/fixtures/closure_reads_later_module_variable.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_accessor_dispatch.ts b/crates/submilli-engine/tests/fixtures/closure_sig_accessor_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_accessor_dispatch.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_accessor_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_after_substitution.ts b/crates/submilli-engine/tests/fixtures/closure_sig_after_substitution.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_after_substitution.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_after_substitution.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_from_class_members.ts b/crates/submilli-engine/tests/fixtures/closure_sig_from_class_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_from_class_members.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_from_class_members.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_from_local_slot.ts b/crates/submilli-engine/tests/fixtures/closure_sig_from_local_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_from_local_slot.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_from_local_slot.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_from_uncalled_signatures.ts b/crates/submilli-engine/tests/fixtures/closure_sig_from_uncalled_signatures.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_from_uncalled_signatures.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_from_uncalled_signatures.ts diff --git a/crates/interpreter/tests/fixtures/closure_sig_shape_dispatch.ts b/crates/submilli-engine/tests/fixtures/closure_sig_shape_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_sig_shape_dispatch.ts rename to crates/submilli-engine/tests/fixtures/closure_sig_shape_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/closure_that_only_throws_is_never.ts b/crates/submilli-engine/tests/fixtures/closure_that_only_throws_is_never.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closure_that_only_throws_is_never.ts rename to crates/submilli-engine/tests/fixtures/closure_that_only_throws_is_never.ts diff --git a/crates/interpreter/tests/fixtures/closure_variable_passed_to_hof.subm b/crates/submilli-engine/tests/fixtures/closure_variable_passed_to_hof.subm similarity index 100% rename from crates/interpreter/tests/fixtures/closure_variable_passed_to_hof.subm rename to crates/submilli-engine/tests/fixtures/closure_variable_passed_to_hof.subm diff --git a/crates/interpreter/tests/fixtures/closures/callbacks_declare_fewer_params.ts b/crates/submilli-engine/tests/fixtures/closures/callbacks_declare_fewer_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/callbacks_declare_fewer_params.ts rename to crates/submilli-engine/tests/fixtures/closures/callbacks_declare_fewer_params.ts diff --git a/crates/interpreter/tests/fixtures/closures/function_arity_edges.ts b/crates/submilli-engine/tests/fixtures/closures/function_arity_edges.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/function_arity_edges.ts rename to crates/submilli-engine/tests/fixtures/closures/function_arity_edges.ts diff --git a/crates/interpreter/tests/fixtures/closures/function_this.ts b/crates/submilli-engine/tests/fixtures/closures/function_this.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/function_this.ts rename to crates/submilli-engine/tests/fixtures/closures/function_this.ts diff --git a/crates/interpreter/tests/fixtures/closures/iife.subm b/crates/submilli-engine/tests/fixtures/closures/iife.subm similarity index 100% rename from crates/interpreter/tests/fixtures/closures/iife.subm rename to crates/submilli-engine/tests/fixtures/closures/iife.subm diff --git a/crates/interpreter/tests/fixtures/closures/named_function_expression.ts b/crates/submilli-engine/tests/fixtures/closures/named_function_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/named_function_expression.ts rename to crates/submilli-engine/tests/fixtures/closures/named_function_expression.ts diff --git a/crates/interpreter/tests/fixtures/closures/nested_function_contexts.ts b/crates/submilli-engine/tests/fixtures/closures/nested_function_contexts.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/nested_function_contexts.ts rename to crates/submilli-engine/tests/fixtures/closures/nested_function_contexts.ts diff --git a/crates/interpreter/tests/fixtures/closures/nested_function_declarations.ts b/crates/submilli-engine/tests/fixtures/closures/nested_function_declarations.ts similarity index 100% rename from crates/interpreter/tests/fixtures/closures/nested_function_declarations.ts rename to crates/submilli-engine/tests/fixtures/closures/nested_function_declarations.ts diff --git a/crates/interpreter/tests/fixtures/code/linear_diff.ts b/crates/submilli-engine/tests/fixtures/code/linear_diff.ts similarity index 100% rename from crates/interpreter/tests/fixtures/code/linear_diff.ts rename to crates/submilli-engine/tests/fixtures/code/linear_diff.ts diff --git a/crates/interpreter/tests/fixtures/code/workspace.ts b/crates/submilli-engine/tests/fixtures/code/workspace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/code/workspace.ts rename to crates/submilli-engine/tests/fixtures/code/workspace.ts diff --git a/crates/interpreter/tests/fixtures/collection_iterators_live.ts b/crates/submilli-engine/tests/fixtures/collection_iterators_live.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_iterators_live.ts rename to crates/submilli-engine/tests/fixtures/collection_iterators_live.ts diff --git a/crates/interpreter/tests/fixtures/collection_keys_same_value_zero.ts b/crates/submilli-engine/tests/fixtures/collection_keys_same_value_zero.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_keys_same_value_zero.ts rename to crates/submilli-engine/tests/fixtures/collection_keys_same_value_zero.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/array_from_mapping.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/array_from_mapping.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/array_from_mapping.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/array_from_mapping.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/array_from_nullable.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/array_from_nullable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/array_from_nullable.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/array_from_nullable.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/array_postfix_only.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/array_postfix_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/array_postfix_only.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/array_postfix_only.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_arity.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_arity.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_arity.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_array.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_array.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_array.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_slot.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_slot.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_slot.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/optional_index.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/optional_index.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/optional_index.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/optional_index.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/optional_index_bounds.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/optional_index_bounds.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/optional_index_bounds.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/optional_index_bounds.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/spread_order.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/spread_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/spread_order.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/spread_order.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/tuple_boxing.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/tuple_boxing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/tuple_boxing.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/tuple_boxing.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/tuple_spread.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/tuple_spread.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/tuple_spread.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/tuple_spread.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix.ts diff --git a/crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix_only.ts b/crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix_only.ts rename to crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix_only.ts diff --git a/crates/interpreter/tests/fixtures/collection_to_string_tag.ts b/crates/submilli-engine/tests/fixtures/collection_to_string_tag.ts similarity index 100% rename from crates/interpreter/tests/fixtures/collection_to_string_tag.ts rename to crates/submilli-engine/tests/fixtures/collection_to_string_tag.ts diff --git a/crates/interpreter/tests/fixtures/comparable_methods_and_self_references.ts b/crates/submilli-engine/tests/fixtures/comparable_methods_and_self_references.ts similarity index 100% rename from crates/interpreter/tests/fixtures/comparable_methods_and_self_references.ts rename to crates/submilli-engine/tests/fixtures/comparable_methods_and_self_references.ts diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_basic_number.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_basic_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_basic_number.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_basic_number.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_bigint.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_bigint.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_bigint.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_bigint.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_const_error.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_const_error.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_const_error.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_const_error.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_field.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_field.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_field.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_for_loop.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_for_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_for_loop.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_for_loop.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_index.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_index.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_index.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_index.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_narrowing.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_narrowing.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_pow_precedence.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_pow_precedence.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_pow_precedence.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_pow_precedence.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_string.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_string.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_string.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_type_error_mixed.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_mixed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_type_error_mixed.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_mixed.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/compound_type_error_string_sub.subm b/crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_string_sub.subm similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/compound_type_error_string_sub.subm rename to crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_string_sub.subm diff --git a/crates/interpreter/tests/fixtures/compound_assign/receiver_evaluated_once.ts b/crates/submilli-engine/tests/fixtures/compound_assign/receiver_evaluated_once.ts similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assign/receiver_evaluated_once.ts rename to crates/submilli-engine/tests/fixtures/compound_assign/receiver_evaluated_once.ts diff --git a/crates/interpreter/tests/fixtures/compound_assignment_through_never_getter.ts b/crates/submilli-engine/tests/fixtures/compound_assignment_through_never_getter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/compound_assignment_through_never_getter.ts rename to crates/submilli-engine/tests/fixtures/compound_assignment_through_never_getter.ts diff --git a/crates/interpreter/tests/fixtures/compound_write_widens_literal_target.ts b/crates/submilli-engine/tests/fixtures/compound_write_widens_literal_target.ts similarity index 100% rename from crates/interpreter/tests/fixtures/compound_write_widens_literal_target.ts rename to crates/submilli-engine/tests/fixtures/compound_write_widens_literal_target.ts diff --git a/crates/interpreter/tests/fixtures/conditional_object_literal_normalization.ts b/crates/submilli-engine/tests/fixtures/conditional_object_literal_normalization.ts similarity index 100% rename from crates/interpreter/tests/fixtures/conditional_object_literal_normalization.ts rename to crates/submilli-engine/tests/fixtures/conditional_object_literal_normalization.ts diff --git a/crates/interpreter/tests/fixtures/conformance_array.subm b/crates/submilli-engine/tests/fixtures/conformance_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_array.subm rename to crates/submilli-engine/tests/fixtures/conformance_array.subm diff --git a/crates/interpreter/tests/fixtures/conformance_bigint.subm b/crates/submilli-engine/tests/fixtures/conformance_bigint.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_bigint.subm rename to crates/submilli-engine/tests/fixtures/conformance_bigint.subm diff --git a/crates/interpreter/tests/fixtures/conformance_boolean.subm b/crates/submilli-engine/tests/fixtures/conformance_boolean.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_boolean.subm rename to crates/submilli-engine/tests/fixtures/conformance_boolean.subm diff --git a/crates/interpreter/tests/fixtures/conformance_json.subm b/crates/submilli-engine/tests/fixtures/conformance_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_json.subm rename to crates/submilli-engine/tests/fixtures/conformance_json.subm diff --git a/crates/interpreter/tests/fixtures/conformance_map_set.subm b/crates/submilli-engine/tests/fixtures/conformance_map_set.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_map_set.subm rename to crates/submilli-engine/tests/fixtures/conformance_map_set.subm diff --git a/crates/interpreter/tests/fixtures/conformance_math.subm b/crates/submilli-engine/tests/fixtures/conformance_math.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_math.subm rename to crates/submilli-engine/tests/fixtures/conformance_math.subm diff --git a/crates/interpreter/tests/fixtures/conformance_number.subm b/crates/submilli-engine/tests/fixtures/conformance_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_number.subm rename to crates/submilli-engine/tests/fixtures/conformance_number.subm diff --git a/crates/interpreter/tests/fixtures/conformance_object.subm b/crates/submilli-engine/tests/fixtures/conformance_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_object.subm rename to crates/submilli-engine/tests/fixtures/conformance_object.subm diff --git a/crates/interpreter/tests/fixtures/conformance_regexp.subm b/crates/submilli-engine/tests/fixtures/conformance_regexp.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_regexp.subm rename to crates/submilli-engine/tests/fixtures/conformance_regexp.subm diff --git a/crates/interpreter/tests/fixtures/conformance_string.subm b/crates/submilli-engine/tests/fixtures/conformance_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_string.subm rename to crates/submilli-engine/tests/fixtures/conformance_string.subm diff --git a/crates/interpreter/tests/fixtures/conformance_temporal.subm b/crates/submilli-engine/tests/fixtures/conformance_temporal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_temporal.subm rename to crates/submilli-engine/tests/fixtures/conformance_temporal.subm diff --git a/crates/interpreter/tests/fixtures/conformance_uint8array.subm b/crates/submilli-engine/tests/fixtures/conformance_uint8array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/conformance_uint8array.subm rename to crates/submilli-engine/tests/fixtures/conformance_uint8array.subm diff --git a/crates/interpreter/tests/fixtures/console_log_null.ts b/crates/submilli-engine/tests/fixtures/console_log_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/console_log_null.ts rename to crates/submilli-engine/tests/fixtures/console_log_null.ts diff --git a/crates/interpreter/tests/fixtures/console_log_variadic.subm b/crates/submilli-engine/tests/fixtures/console_log_variadic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/console_log_variadic.subm rename to crates/submilli-engine/tests/fixtures/console_log_variadic.subm diff --git a/crates/interpreter/tests/fixtures/const_keeps_literals_through_operators.ts b/crates/submilli-engine/tests/fixtures/const_keeps_literals_through_operators.ts similarity index 100% rename from crates/interpreter/tests/fixtures/const_keeps_literals_through_operators.ts rename to crates/submilli-engine/tests/fixtures/const_keeps_literals_through_operators.ts diff --git a/crates/interpreter/tests/fixtures/const_literal_survives_through_ternaries.ts b/crates/submilli-engine/tests/fixtures/const_literal_survives_through_ternaries.ts similarity index 100% rename from crates/interpreter/tests/fixtures/const_literal_survives_through_ternaries.ts rename to crates/submilli-engine/tests/fixtures/const_literal_survives_through_ternaries.ts diff --git a/crates/interpreter/tests/fixtures/const_literal_survives_where_immutable.ts b/crates/submilli-engine/tests/fixtures/const_literal_survives_where_immutable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/const_literal_survives_where_immutable.ts rename to crates/submilli-engine/tests/fixtures/const_literal_survives_where_immutable.ts diff --git a/crates/interpreter/tests/fixtures/const_literal_widens_where_mutable.ts b/crates/submilli-engine/tests/fixtures/const_literal_widens_where_mutable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/const_literal_widens_where_mutable.ts rename to crates/submilli-engine/tests/fixtures/const_literal_widens_where_mutable.ts diff --git a/crates/interpreter/tests/fixtures/constant_expression_literal_types.ts b/crates/submilli-engine/tests/fixtures/constant_expression_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/constant_expression_literal_types.ts rename to crates/submilli-engine/tests/fixtures/constant_expression_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/constant_key_reads_as_field.ts b/crates/submilli-engine/tests/fixtures/constant_key_reads_as_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/constant_key_reads_as_field.ts rename to crates/submilli-engine/tests/fixtures/constant_key_reads_as_field.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/all_five_as_names.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/all_five_as_names.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/all_five_as_names.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/all_five_as_names.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/from_binding_template.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/from_binding_template.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/from_binding_template.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/from_binding_template.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_inline.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_inline.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_inline.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_inline.ts diff --git a/crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_statement.ts b/crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_statement.ts similarity index 100% rename from crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_statement.ts rename to crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_statement.ts diff --git a/crates/interpreter/tests/fixtures/conversion_field_rest_and_this.ts b/crates/submilli-engine/tests/fixtures/conversion_field_rest_and_this.ts similarity index 100% rename from crates/interpreter/tests/fixtures/conversion_field_rest_and_this.ts rename to crates/submilli-engine/tests/fixtures/conversion_field_rest_and_this.ts diff --git a/crates/interpreter/tests/fixtures/crypto/hmac_sha256.subm b/crates/submilli-engine/tests/fixtures/crypto/hmac_sha256.subm similarity index 100% rename from crates/interpreter/tests/fixtures/crypto/hmac_sha256.subm rename to crates/submilli-engine/tests/fixtures/crypto/hmac_sha256.subm diff --git a/crates/interpreter/tests/fixtures/crypto/random_bytes.subm b/crates/submilli-engine/tests/fixtures/crypto/random_bytes.subm similarity index 100% rename from crates/interpreter/tests/fixtures/crypto/random_bytes.subm rename to crates/submilli-engine/tests/fixtures/crypto/random_bytes.subm diff --git a/crates/interpreter/tests/fixtures/crypto/sha256.subm b/crates/submilli-engine/tests/fixtures/crypto/sha256.subm similarity index 100% rename from crates/interpreter/tests/fixtures/crypto/sha256.subm rename to crates/submilli-engine/tests/fixtures/crypto/sha256.subm diff --git a/crates/interpreter/tests/fixtures/crypto/sha512.subm b/crates/submilli-engine/tests/fixtures/crypto/sha512.subm similarity index 100% rename from crates/interpreter/tests/fixtures/crypto/sha512.subm rename to crates/submilli-engine/tests/fixtures/crypto/sha512.subm diff --git a/crates/interpreter/tests/fixtures/crypto/timing_safe_equal.subm b/crates/submilli-engine/tests/fixtures/crypto/timing_safe_equal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/crypto/timing_safe_equal.subm rename to crates/submilli-engine/tests/fixtures/crypto/timing_safe_equal.subm diff --git a/crates/interpreter/tests/fixtures/cyclic_graph_host_walk.ts b/crates/submilli-engine/tests/fixtures/cyclic_graph_host_walk.ts similarity index 100% rename from crates/interpreter/tests/fixtures/cyclic_graph_host_walk.ts rename to crates/submilli-engine/tests/fixtures/cyclic_graph_host_walk.ts diff --git a/crates/interpreter/tests/fixtures/date_lowercase_variable_works.subm b/crates/submilli-engine/tests/fixtures/date_lowercase_variable_works.subm similarity index 100% rename from crates/interpreter/tests/fixtures/date_lowercase_variable_works.subm rename to crates/submilli-engine/tests/fixtures/date_lowercase_variable_works.subm diff --git a/crates/interpreter/tests/fixtures/decode_uri_lone_surrogates.ts b/crates/submilli-engine/tests/fixtures/decode_uri_lone_surrogates.ts similarity index 100% rename from crates/interpreter/tests/fixtures/decode_uri_lone_surrogates.ts rename to crates/submilli-engine/tests/fixtures/decode_uri_lone_surrogates.ts diff --git a/crates/interpreter/tests/fixtures/default_param_arrow.ts b/crates/submilli-engine/tests/fixtures/default_param_arrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_arrow.ts rename to crates/submilli-engine/tests/fixtures/default_param_arrow.ts diff --git a/crates/interpreter/tests/fixtures/default_param_basic.subm b/crates/submilli-engine/tests/fixtures/default_param_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_basic.subm rename to crates/submilli-engine/tests/fixtures/default_param_basic.subm diff --git a/crates/interpreter/tests/fixtures/default_param_before_required.ts b/crates/submilli-engine/tests/fixtures/default_param_before_required.ts similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_before_required.ts rename to crates/submilli-engine/tests/fixtures/default_param_before_required.ts diff --git a/crates/interpreter/tests/fixtures/default_param_boxed_slot.ts b/crates/submilli-engine/tests/fixtures/default_param_boxed_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_boxed_slot.ts rename to crates/submilli-engine/tests/fixtures/default_param_boxed_slot.ts diff --git a/crates/interpreter/tests/fixtures/default_param_enum_variant.subm b/crates/submilli-engine/tests/fixtures/default_param_enum_variant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_enum_variant.subm rename to crates/submilli-engine/tests/fixtures/default_param_enum_variant.subm diff --git a/crates/interpreter/tests/fixtures/default_param_expression.ts b/crates/submilli-engine/tests/fixtures/default_param_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_expression.ts rename to crates/submilli-engine/tests/fixtures/default_param_expression.ts diff --git a/crates/interpreter/tests/fixtures/default_param_global_const.ts b/crates/submilli-engine/tests/fixtures/default_param_global_const.ts similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_global_const.ts rename to crates/submilli-engine/tests/fixtures/default_param_global_const.ts diff --git a/crates/interpreter/tests/fixtures/default_param_method.subm b/crates/submilli-engine/tests/fixtures/default_param_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/default_param_method.subm rename to crates/submilli-engine/tests/fixtures/default_param_method.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/array_hole.subm b/crates/submilli-engine/tests/fixtures/destructuring/array_hole.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/array_hole.subm rename to crates/submilli-engine/tests/fixtures/destructuring/array_hole.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/array_literal_as_tuple.subm b/crates/submilli-engine/tests/fixtures/destructuring/array_literal_as_tuple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/array_literal_as_tuple.subm rename to crates/submilli-engine/tests/fixtures/destructuring/array_literal_as_tuple.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/array_positional.subm b/crates/submilli-engine/tests/fixtures/destructuring/array_positional.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/array_positional.subm rename to crates/submilli-engine/tests/fixtures/destructuring/array_positional.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/array_rest.subm b/crates/submilli-engine/tests/fixtures/destructuring/array_rest.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/array_rest.subm rename to crates/submilli-engine/tests/fixtures/destructuring/array_rest.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/arrow_param_expr_body.subm b/crates/submilli-engine/tests/fixtures/destructuring/arrow_param_expr_body.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/arrow_param_expr_body.subm rename to crates/submilli-engine/tests/fixtures/destructuring/arrow_param_expr_body.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/class_member_params.ts b/crates/submilli-engine/tests/fixtures/destructuring/class_member_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/class_member_params.ts rename to crates/submilli-engine/tests/fixtures/destructuring/class_member_params.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts b/crates/submilli-engine/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts rename to crates/submilli-engine/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_array_literal_arity.subm b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_array_literal_arity.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_array_literal_arity.subm rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_array_literal_arity.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_arity.subm b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_arity.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_arity.subm rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_arity.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_nested.subm b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_nested.subm rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_nested.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/expect_error_rest_not_last.subm b/crates/submilli-engine/tests/fixtures/destructuring/expect_error_rest_not_last.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/expect_error_rest_not_last.subm rename to crates/submilli-engine/tests/fixtures/destructuring/expect_error_rest_not_last.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/for_initializer.ts b/crates/submilli-engine/tests/fixtures/destructuring/for_initializer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/for_initializer.ts rename to crates/submilli-engine/tests/fixtures/destructuring/for_initializer.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/for_of_map.subm b/crates/submilli-engine/tests/fixtures/destructuring/for_of_map.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/for_of_map.subm rename to crates/submilli-engine/tests/fixtures/destructuring/for_of_map.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/for_of_tuple.subm b/crates/submilli-engine/tests/fixtures/destructuring/for_of_tuple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/for_of_tuple.subm rename to crates/submilli-engine/tests/fixtures/destructuring/for_of_tuple.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/function_param.subm b/crates/submilli-engine/tests/fixtures/destructuring/function_param.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/function_param.subm rename to crates/submilli-engine/tests/fixtures/destructuring/function_param.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/let_pattern_mutation.subm b/crates/submilli-engine/tests/fixtures/destructuring/let_pattern_mutation.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/let_pattern_mutation.subm rename to crates/submilli-engine/tests/fixtures/destructuring/let_pattern_mutation.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/nested_in_block.subm b/crates/submilli-engine/tests/fixtures/destructuring/nested_in_block.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/nested_in_block.subm rename to crates/submilli-engine/tests/fixtures/destructuring/nested_in_block.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/object_rename.subm b/crates/submilli-engine/tests/fixtures/destructuring/object_rename.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/object_rename.subm rename to crates/submilli-engine/tests/fixtures/destructuring/object_rename.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/object_rest.subm b/crates/submilli-engine/tests/fixtures/destructuring/object_rest.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/object_rest.subm rename to crates/submilli-engine/tests/fixtures/destructuring/object_rest.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/object_shorthand.subm b/crates/submilli-engine/tests/fixtures/destructuring/object_shorthand.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/object_shorthand.subm rename to crates/submilli-engine/tests/fixtures/destructuring/object_shorthand.subm diff --git a/crates/interpreter/tests/fixtures/destructuring/parameter_defaults.ts b/crates/submilli-engine/tests/fixtures/destructuring/parameter_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/parameter_defaults.ts rename to crates/submilli-engine/tests/fixtures/destructuring/parameter_defaults.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/pattern_defaults.ts b/crates/submilli-engine/tests/fixtures/destructuring/pattern_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/pattern_defaults.ts rename to crates/submilli-engine/tests/fixtures/destructuring/pattern_defaults.ts diff --git a/crates/interpreter/tests/fixtures/destructuring/single_eval_rhs.subm b/crates/submilli-engine/tests/fixtures/destructuring/single_eval_rhs.subm similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring/single_eval_rhs.subm rename to crates/submilli-engine/tests/fixtures/destructuring/single_eval_rhs.subm diff --git a/crates/interpreter/tests/fixtures/destructuring_initializer_flow.ts b/crates/submilli-engine/tests/fixtures/destructuring_initializer_flow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/destructuring_initializer_flow.ts rename to crates/submilli-engine/tests/fixtures/destructuring_initializer_flow.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/accessor.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/accessor.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/accessor.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/array.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/array.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/array.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/getter.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/getter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/getter.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/getter.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/interface.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/interface.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/interface.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/spread_array.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/spread_array.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_array.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/spread_tuple.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_tuple.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/spread_tuple.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_tuple.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/tuple.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/tuple.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/tuple.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/tuple.ts diff --git a/crates/interpreter/tests/fixtures/diagnostic_counts/unhinted_array.ts b/crates/submilli-engine/tests/fixtures/diagnostic_counts/unhinted_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/diagnostic_counts/unhinted_array.ts rename to crates/submilli-engine/tests/fixtures/diagnostic_counts/unhinted_array.ts diff --git a/crates/interpreter/tests/fixtures/discriminated_union_object_literal.subm b/crates/submilli-engine/tests/fixtures/discriminated_union_object_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/discriminated_union_object_literal.subm rename to crates/submilli-engine/tests/fixtures/discriminated_union_object_literal.subm diff --git a/crates/interpreter/tests/fixtures/doc_callable_members.ts b/crates/submilli-engine/tests/fixtures/doc_callable_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/doc_callable_members.ts rename to crates/submilli-engine/tests/fixtures/doc_callable_members.ts diff --git a/crates/interpreter/tests/fixtures/doc_comments/capability_context_fields.ts b/crates/submilli-engine/tests/fixtures/doc_comments/capability_context_fields.ts similarity index 100% rename from crates/interpreter/tests/fixtures/doc_comments/capability_context_fields.ts rename to crates/submilli-engine/tests/fixtures/doc_comments/capability_context_fields.ts diff --git a/crates/interpreter/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts b/crates/submilli-engine/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts similarity index 100% rename from crates/interpreter/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts rename to crates/submilli-engine/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts diff --git a/crates/interpreter/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm b/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm similarity index 100% rename from crates/interpreter/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm rename to crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm diff --git a/crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm b/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm similarity index 100% rename from crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm rename to crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm diff --git a/crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm b/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm similarity index 100% rename from crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm rename to crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm diff --git a/crates/interpreter/tests/fixtures/duplicate_parameter_names.ts b/crates/submilli-engine/tests/fixtures/duplicate_parameter_names.ts similarity index 100% rename from crates/interpreter/tests/fixtures/duplicate_parameter_names.ts rename to crates/submilli-engine/tests/fixtures/duplicate_parameter_names.ts diff --git a/crates/interpreter/tests/fixtures/embedding_basic.ts b/crates/submilli-engine/tests/fixtures/embedding_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_basic.ts rename to crates/submilli-engine/tests/fixtures/embedding_basic.ts diff --git a/crates/interpreter/tests/fixtures/embedding_bounds.ts b/crates/submilli-engine/tests/fixtures/embedding_bounds.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_bounds.ts rename to crates/submilli-engine/tests/fixtures/embedding_bounds.ts diff --git a/crates/interpreter/tests/fixtures/embedding_budget_per_run.ts b/crates/submilli-engine/tests/fixtures/embedding_budget_per_run.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_budget_per_run.ts rename to crates/submilli-engine/tests/fixtures/embedding_budget_per_run.ts diff --git a/crates/interpreter/tests/fixtures/embedding_denied.ts b/crates/submilli-engine/tests/fixtures/embedding_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_denied.ts rename to crates/submilli-engine/tests/fixtures/embedding_denied.ts diff --git a/crates/interpreter/tests/fixtures/embedding_error_taxonomy.ts b/crates/submilli-engine/tests/fixtures/embedding_error_taxonomy.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_error_taxonomy.ts rename to crates/submilli-engine/tests/fixtures/embedding_error_taxonomy.ts diff --git a/crates/interpreter/tests/fixtures/embedding_input_too_long.ts b/crates/submilli-engine/tests/fixtures/embedding_input_too_long.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_input_too_long.ts rename to crates/submilli-engine/tests/fixtures/embedding_input_too_long.ts diff --git a/crates/interpreter/tests/fixtures/embedding_models.ts b/crates/submilli-engine/tests/fixtures/embedding_models.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_models.ts rename to crates/submilli-engine/tests/fixtures/embedding_models.ts diff --git a/crates/interpreter/tests/fixtures/embedding_models_filtered.ts b/crates/submilli-engine/tests/fixtures/embedding_models_filtered.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_models_filtered.ts rename to crates/submilli-engine/tests/fixtures/embedding_models_filtered.ts diff --git a/crates/interpreter/tests/fixtures/embedding_no_provider.ts b/crates/submilli-engine/tests/fixtures/embedding_no_provider.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_no_provider.ts rename to crates/submilli-engine/tests/fixtures/embedding_no_provider.ts diff --git a/crates/interpreter/tests/fixtures/embedding_purpose_invalid.ts b/crates/submilli-engine/tests/fixtures/embedding_purpose_invalid.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_purpose_invalid.ts rename to crates/submilli-engine/tests/fixtures/embedding_purpose_invalid.ts diff --git a/crates/interpreter/tests/fixtures/embedding_unknown_alias.ts b/crates/submilli-engine/tests/fixtures/embedding_unknown_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/embedding_unknown_alias.ts rename to crates/submilli-engine/tests/fixtures/embedding_unknown_alias.ts diff --git a/crates/interpreter/tests/fixtures/emitter_fallible_healthy.ts b/crates/submilli-engine/tests/fixtures/emitter_fallible_healthy.ts similarity index 100% rename from crates/interpreter/tests/fixtures/emitter_fallible_healthy.ts rename to crates/submilli-engine/tests/fixtures/emitter_fallible_healthy.ts diff --git a/crates/interpreter/tests/fixtures/emitter_state_healthy.ts b/crates/submilli-engine/tests/fixtures/emitter_state_healthy.ts similarity index 100% rename from crates/interpreter/tests/fixtures/emitter_state_healthy.ts rename to crates/submilli-engine/tests/fixtures/emitter_state_healthy.ts diff --git a/crates/interpreter/tests/fixtures/empty_array_cast.ts b/crates/submilli-engine/tests/fixtures/empty_array_cast.ts similarity index 100% rename from crates/interpreter/tests/fixtures/empty_array_cast.ts rename to crates/submilli-engine/tests/fixtures/empty_array_cast.ts diff --git a/crates/interpreter/tests/fixtures/empty_array_cast_non_array.ts b/crates/submilli-engine/tests/fixtures/empty_array_cast_non_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/empty_array_cast_non_array.ts rename to crates/submilli-engine/tests/fixtures/empty_array_cast_non_array.ts diff --git a/crates/interpreter/tests/fixtures/empty_array_never.ts b/crates/submilli-engine/tests/fixtures/empty_array_never.ts similarity index 100% rename from crates/interpreter/tests/fixtures/empty_array_never.ts rename to crates/submilli-engine/tests/fixtures/empty_array_never.ts diff --git a/crates/interpreter/tests/fixtures/enum_member_cases_match_their_own_enum.ts b/crates/submilli-engine/tests/fixtures/enum_member_cases_match_their_own_enum.ts similarity index 100% rename from crates/interpreter/tests/fixtures/enum_member_cases_match_their_own_enum.ts rename to crates/submilli-engine/tests/fixtures/enum_member_cases_match_their_own_enum.ts diff --git a/crates/interpreter/tests/fixtures/enum_member_comparison_narrows.ts b/crates/submilli-engine/tests/fixtures/enum_member_comparison_narrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/enum_member_comparison_narrows.ts rename to crates/submilli-engine/tests/fixtures/enum_member_comparison_narrows.ts diff --git a/crates/interpreter/tests/fixtures/enum_member_types.ts b/crates/submilli-engine/tests/fixtures/enum_member_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/enum_member_types.ts rename to crates/submilli-engine/tests/fixtures/enum_member_types.ts diff --git a/crates/interpreter/tests/fixtures/enum_negative_zero_initializer.ts b/crates/submilli-engine/tests/fixtures/enum_negative_zero_initializer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/enum_negative_zero_initializer.ts rename to crates/submilli-engine/tests/fixtures/enum_negative_zero_initializer.ts diff --git a/crates/interpreter/tests/fixtures/enums/enum_decl_numeric_typechecks.subm b/crates/submilli-engine/tests/fixtures/enums/enum_decl_numeric_typechecks.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/enum_decl_numeric_typechecks.subm rename to crates/submilli-engine/tests/fixtures/enums/enum_decl_numeric_typechecks.subm diff --git a/crates/interpreter/tests/fixtures/enums/enum_decl_string_typechecks.subm b/crates/submilli-engine/tests/fixtures/enums/enum_decl_string_typechecks.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/enum_decl_string_typechecks.subm rename to crates/submilli-engine/tests/fixtures/enums/enum_decl_string_typechecks.subm diff --git a/crates/interpreter/tests/fixtures/enums/enum_runtime_numeric.subm b/crates/submilli-engine/tests/fixtures/enums/enum_runtime_numeric.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/enum_runtime_numeric.subm rename to crates/submilli-engine/tests/fixtures/enums/enum_runtime_numeric.subm diff --git a/crates/interpreter/tests/fixtures/enums/enum_runtime_string.subm b/crates/submilli-engine/tests/fixtures/enums/enum_runtime_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/enum_runtime_string.subm rename to crates/submilli-engine/tests/fixtures/enums/enum_runtime_string.subm diff --git a/crates/interpreter/tests/fixtures/enums/expect_error_enum_as_value.subm b/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_as_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/expect_error_enum_as_value.subm rename to crates/submilli-engine/tests/fixtures/enums/expect_error_enum_as_value.subm diff --git a/crates/interpreter/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm b/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm rename to crates/submilli-engine/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm diff --git a/crates/interpreter/tests/fixtures/enums/expect_error_enum_string_missing_value.subm b/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_string_missing_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/expect_error_enum_string_missing_value.subm rename to crates/submilli-engine/tests/fixtures/enums/expect_error_enum_string_missing_value.subm diff --git a/crates/interpreter/tests/fixtures/enums/expect_error_enum_unknown_variant.subm b/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_unknown_variant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/enums/expect_error_enum_unknown_variant.subm rename to crates/submilli-engine/tests/fixtures/enums/expect_error_enum_unknown_variant.subm diff --git a/crates/interpreter/tests/fixtures/equality_comparable_operands.ts b/crates/submilli-engine/tests/fixtures/equality_comparable_operands.ts similarity index 100% rename from crates/interpreter/tests/fixtures/equality_comparable_operands.ts rename to crates/submilli-engine/tests/fixtures/equality_comparable_operands.ts diff --git a/crates/interpreter/tests/fixtures/equality_literal_operands.ts b/crates/submilli-engine/tests/fixtures/equality_literal_operands.ts similarity index 100% rename from crates/interpreter/tests/fixtures/equality_literal_operands.ts rename to crates/submilli-engine/tests/fixtures/equality_literal_operands.ts diff --git a/crates/interpreter/tests/fixtures/error_constructor_default_message.ts b/crates/submilli-engine/tests/fixtures/error_constructor_default_message.ts similarity index 100% rename from crates/interpreter/tests/fixtures/error_constructor_default_message.ts rename to crates/submilli-engine/tests/fixtures/error_constructor_default_message.ts diff --git a/crates/interpreter/tests/fixtures/error_is_error.subm b/crates/submilli-engine/tests/fixtures/error_is_error.subm similarity index 100% rename from crates/interpreter/tests/fixtures/error_is_error.subm rename to crates/submilli-engine/tests/fixtures/error_is_error.subm diff --git a/crates/interpreter/tests/fixtures/error_is_error_nominal.ts b/crates/submilli-engine/tests/fixtures/error_is_error_nominal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/error_is_error_nominal.ts rename to crates/submilli-engine/tests/fixtures/error_is_error_nominal.ts diff --git a/crates/interpreter/tests/fixtures/error_subclass_object_keys.ts b/crates/submilli-engine/tests/fixtures/error_subclass_object_keys.ts similarity index 100% rename from crates/interpreter/tests/fixtures/error_subclass_object_keys.ts rename to crates/submilli-engine/tests/fixtures/error_subclass_object_keys.ts diff --git a/crates/interpreter/tests/fixtures/error_subclass_to_string.ts b/crates/submilli-engine/tests/fixtures/error_subclass_to_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/error_subclass_to_string.ts rename to crates/submilli-engine/tests/fixtures/error_subclass_to_string.ts diff --git a/crates/interpreter/tests/fixtures/errors/call_sig_duplicate.subm b/crates/submilli-engine/tests/fixtures/errors/call_sig_duplicate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/call_sig_duplicate.subm rename to crates/submilli-engine/tests/fixtures/errors/call_sig_duplicate.subm diff --git a/crates/interpreter/tests/fixtures/errors/call_sig_not_callable.subm b/crates/submilli-engine/tests/fixtures/errors/call_sig_not_callable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/call_sig_not_callable.subm rename to crates/submilli-engine/tests/fixtures/errors/call_sig_not_callable.subm diff --git a/crates/interpreter/tests/fixtures/errors/default_param_in_fn_type.subm b/crates/submilli-engine/tests/fixtures/errors/default_param_in_fn_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/default_param_in_fn_type.subm rename to crates/submilli-engine/tests/fixtures/errors/default_param_in_fn_type.subm diff --git a/crates/interpreter/tests/fixtures/errors/default_param_type_mismatch.subm b/crates/submilli-engine/tests/fixtures/errors/default_param_type_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/default_param_type_mismatch.subm rename to crates/submilli-engine/tests/fixtures/errors/default_param_type_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm b/crates/submilli-engine/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm rename to crates/submilli-engine/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm diff --git a/crates/interpreter/tests/fixtures/errors/issue_918_partial_catalog.ts b/crates/submilli-engine/tests/fixtures/errors/issue_918_partial_catalog.ts similarity index 100% rename from crates/interpreter/tests/fixtures/errors/issue_918_partial_catalog.ts rename to crates/submilli-engine/tests/fixtures/errors/issue_918_partial_catalog.ts diff --git a/crates/interpreter/tests/fixtures/errors/new_no_constructor.subm b/crates/submilli-engine/tests/fixtures/errors/new_no_constructor.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/new_no_constructor.subm rename to crates/submilli-engine/tests/fixtures/errors/new_no_constructor.subm diff --git a/crates/interpreter/tests/fixtures/errors/new_no_parens.subm b/crates/submilli-engine/tests/fixtures/errors/new_no_parens.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/new_no_parens.subm rename to crates/submilli-engine/tests/fixtures/errors/new_no_parens.subm diff --git a/crates/interpreter/tests/fixtures/errors/postfix_inc_chain.subm b/crates/submilli-engine/tests/fixtures/errors/postfix_inc_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/postfix_inc_chain.subm rename to crates/submilli-engine/tests/fixtures/errors/postfix_inc_chain.subm diff --git a/crates/interpreter/tests/fixtures/errors/postfix_inc_const.subm b/crates/submilli-engine/tests/fixtures/errors/postfix_inc_const.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/postfix_inc_const.subm rename to crates/submilli-engine/tests/fixtures/errors/postfix_inc_const.subm diff --git a/crates/interpreter/tests/fixtures/errors/postfix_inc_non_numeric.subm b/crates/submilli-engine/tests/fixtures/errors/postfix_inc_non_numeric.subm similarity index 100% rename from crates/interpreter/tests/fixtures/errors/postfix_inc_non_numeric.subm rename to crates/submilli-engine/tests/fixtures/errors/postfix_inc_non_numeric.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/break_outside_finally_scope.subm b/crates/submilli-engine/tests/fixtures/exceptions/break_outside_finally_scope.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/break_outside_finally_scope.subm rename to crates/submilli-engine/tests/fixtures/exceptions/break_outside_finally_scope.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/catch_binding_reassign.ts b/crates/submilli-engine/tests/fixtures/exceptions/catch_binding_reassign.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/catch_binding_reassign.ts rename to crates/submilli-engine/tests/fixtures/exceptions/catch_binding_reassign.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/catch_bindingless.ts b/crates/submilli-engine/tests/fixtures/exceptions/catch_bindingless.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/catch_bindingless.ts rename to crates/submilli-engine/tests/fixtures/exceptions/catch_bindingless.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm b/crates/submilli-engine/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm rename to crates/submilli-engine/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/catch_unknown.ts b/crates/submilli-engine/tests/fixtures/exceptions/catch_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/catch_unknown.ts rename to crates/submilli-engine/tests/fixtures/exceptions/catch_unknown.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/catch_untyped_binds_error.ts b/crates/submilli-engine/tests/fixtures/exceptions/catch_untyped_binds_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/catch_untyped_binds_error.ts rename to crates/submilli-engine/tests/fixtures/exceptions/catch_untyped_binds_error.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm b/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm rename to crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm b/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm rename to crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm b/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm rename to crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/deep_finally_transfers.ts b/crates/submilli-engine/tests/fixtures/exceptions/deep_finally_transfers.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/deep_finally_transfers.ts rename to crates/submilli-engine/tests/fixtures/exceptions/deep_finally_transfers.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/error_default_name.subm b/crates/submilli-engine/tests/fixtures/exceptions/error_default_name.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/error_default_name.subm rename to crates/submilli-engine/tests/fixtures/exceptions/error_default_name.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_bare_throw.subm b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_throw.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_bare_throw.subm rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_throw.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_bare_try.subm b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_try.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_bare_try.subm rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_try.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_any_binding.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_any_binding.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_catch_any_binding.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_any_binding.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/expect_error_throw_non_error.subm b/crates/submilli-engine/tests/fixtures/exceptions/expect_error_throw_non_error.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/expect_error_throw_non_error.subm rename to crates/submilli-engine/tests/fixtures/exceptions/expect_error_throw_non_error.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_caught_path.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_caught_path.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_caught_path.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_caught_path.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_normal_path.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_normal_path.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_normal_path.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_normal_path.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_preserves_pending_completion.ts b/crates/submilli-engine/tests/fixtures/exceptions/finally_preserves_pending_completion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_preserves_pending_completion.ts rename to crates/submilli-engine/tests/fixtures/exceptions/finally_preserves_pending_completion.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_break.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_runs_on_break.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_break.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_continue.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_continue.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_runs_on_continue.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_continue.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_transfer_runs_once.ts b/crates/submilli-engine/tests/fixtures/exceptions/finally_transfer_runs_once.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_transfer_runs_once.ts rename to crates/submilli-engine/tests/fixtures/exceptions/finally_transfer_runs_once.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/finally_with_own_return_wins.subm b/crates/submilli-engine/tests/fixtures/exceptions/finally_with_own_return_wins.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/finally_with_own_return_wins.subm rename to crates/submilli-engine/tests/fixtures/exceptions/finally_with_own_return_wins.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_first_match.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_first_match.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_first_match.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_first_match.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts b/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts rename to crates/submilli-engine/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/nested_finally_on_return.subm b/crates/submilli-engine/tests/fixtures/exceptions/nested_finally_on_return.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/nested_finally_on_return.subm rename to crates/submilli-engine/tests/fixtures/exceptions/nested_finally_on_return.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/nested_try.subm b/crates/submilli-engine/tests/fixtures/exceptions/nested_try.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/nested_try.subm rename to crates/submilli-engine/tests/fixtures/exceptions/nested_try.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/nested_try_finally_break.subm b/crates/submilli-engine/tests/fixtures/exceptions/nested_try_finally_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/nested_try_finally_break.subm rename to crates/submilli-engine/tests/fixtures/exceptions/nested_try_finally_break.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/return_in_finally_continues_outward.ts b/crates/submilli-engine/tests/fixtures/exceptions/return_in_finally_continues_outward.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/return_in_finally_continues_outward.ts rename to crates/submilli-engine/tests/fixtures/exceptions/return_in_finally_continues_outward.ts diff --git a/crates/interpreter/tests/fixtures/exceptions/throw_caught.subm b/crates/submilli-engine/tests/fixtures/exceptions/throw_caught.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/throw_caught.subm rename to crates/submilli-engine/tests/fixtures/exceptions/throw_caught.subm diff --git a/crates/interpreter/tests/fixtures/exceptions/throw_in_function_caught_outside.subm b/crates/submilli-engine/tests/fixtures/exceptions/throw_in_function_caught_outside.subm similarity index 100% rename from crates/interpreter/tests/fixtures/exceptions/throw_in_function_caught_outside.subm rename to crates/submilli-engine/tests/fixtures/exceptions/throw_in_function_caught_outside.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts b/crates/submilli-engine/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts rename to crates/submilli-engine/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_annotated_callback_conflict.ts b/crates/submilli-engine/tests/fixtures/expect_error_annotated_callback_conflict.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_annotated_callback_conflict.ts rename to crates/submilli-engine/tests/fixtures/expect_error_annotated_callback_conflict.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_annotated_destructuring_default.ts b/crates/submilli-engine/tests/fixtures/expect_error_annotated_destructuring_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_annotated_destructuring_default.ts rename to crates/submilli-engine/tests/fixtures/expect_error_annotated_destructuring_default.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_annotated_for_of_default.ts b/crates/submilli-engine/tests/fixtures/expect_error_annotated_for_of_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_annotated_for_of_default.ts rename to crates/submilli-engine/tests/fixtures/expect_error_annotated_for_of_default.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_array_from_array_like_element_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_element_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_from_array_like_element_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_element_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_array_from_array_like_without_callback.ts b/crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_without_callback.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_from_array_like_without_callback.ts rename to crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_without_callback.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_array_from_interface_array_like.ts b/crates/submilli-engine/tests/fixtures/expect_error_array_from_interface_array_like.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_from_interface_array_like.ts rename to crates/submilli-engine/tests/fixtures/expect_error_array_from_interface_array_like.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_array_from_keyed_array_like.subm b/crates/submilli-engine/tests/fixtures/expect_error_array_from_keyed_array_like.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_from_keyed_array_like.subm rename to crates/submilli-engine/tests/fixtures/expect_error_array_from_keyed_array_like.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_array_type_after_line_break.ts b/crates/submilli-engine/tests/fixtures/expect_error_array_type_after_line_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_array_type_after_line_break.ts rename to crates/submilli-engine/tests/fixtures/expect_error_array_type_after_line_break.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_arrow_body_and_signature.ts b/crates/submilli-engine/tests/fixtures/expect_error_arrow_body_and_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_arrow_body_and_signature.ts rename to crates/submilli-engine/tests/fixtures/expect_error_arrow_body_and_signature.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_assignment_expression_to_const.ts b/crates/submilli-engine/tests/fixtures/expect_error_assignment_expression_to_const.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_assignment_expression_to_const.ts rename to crates/submilli-engine/tests/fixtures/expect_error_assignment_expression_to_const.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_assignment_reported_once.ts b/crates/submilli-engine/tests/fixtures/expect_error_assignment_reported_once.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_assignment_reported_once.ts rename to crates/submilli-engine/tests/fixtures/expect_error_assignment_reported_once.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_braceless_declaration_body.ts b/crates/submilli-engine/tests/fixtures/expect_error_braceless_declaration_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_braceless_declaration_body.ts rename to crates/submilli-engine/tests/fixtures/expect_error_braceless_declaration_body.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_braceless_declarations.ts b/crates/submilli-engine/tests/fixtures/expect_error_braceless_declarations.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_braceless_declarations.ts rename to crates/submilli-engine/tests/fixtures/expect_error_braceless_declarations.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_break_in_nested_function.ts b/crates/submilli-engine/tests/fixtures/expect_error_break_in_nested_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_break_in_nested_function.ts rename to crates/submilli-engine/tests/fixtures/expect_error_break_in_nested_function.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_callback_param_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_callback_param_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_callback_param_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_callback_param_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_callback_return_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_callback_return_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_callback_return_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_callback_return_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_callback_too_many_params.ts b/crates/submilli-engine/tests/fixtures/expect_error_callback_too_many_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_callback_too_many_params.ts rename to crates/submilli-engine/tests/fixtures/expect_error_callback_too_many_params.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_callback_untyped_extra_param.ts b/crates/submilli-engine/tests/fixtures/expect_error_callback_untyped_extra_param.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_callback_untyped_extra_param.ts rename to crates/submilli-engine/tests/fixtures/expect_error_callback_untyped_extra_param.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_cast_union_without_member_overlap.ts b/crates/submilli-engine/tests/fixtures/expect_error_cast_union_without_member_overlap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_cast_union_without_member_overlap.ts rename to crates/submilli-engine/tests/fixtures/expect_error_cast_union_without_member_overlap.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_class_chain_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_class_chain_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_class_chain_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_class_chain_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_class_in_function.ts b/crates/submilli-engine/tests/fixtures/expect_error_class_in_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_class_in_function.ts rename to crates/submilli-engine/tests/fixtures/expect_error_class_in_function.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_comparable_function_properties.ts b/crates/submilli-engine/tests/fixtures/expect_error_comparable_function_properties.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_comparable_function_properties.ts rename to crates/submilli-engine/tests/fixtures/expect_error_comparable_function_properties.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_comparison_never_true.ts b/crates/submilli-engine/tests/fixtures/expect_error_comparison_never_true.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_comparison_never_true.ts rename to crates/submilli-engine/tests/fixtures/expect_error_comparison_never_true.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_compound_write_reads_base_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_compound_write_reads_base_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_compound_write_reads_base_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_compound_write_reads_base_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_condition_write_after_narrowing.ts b/crates/submilli-engine/tests/fixtures/expect_error_condition_write_after_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_condition_write_after_narrowing.ts rename to crates/submilli-engine/tests/fixtures/expect_error_condition_write_after_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_const_literal_operators_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_const_literal_operators_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_const_literal_operators_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_const_literal_operators_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_const_literal_union_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_const_literal_union_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_const_literal_union_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_const_literal_union_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts b/crates/submilli-engine/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts rename to crates/submilli-engine/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_date_constructor.subm b/crates/submilli-engine/tests/fixtures/expect_error_date_constructor.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_date_constructor.subm rename to crates/submilli-engine/tests/fixtures/expect_error_date_constructor.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_date_now.subm b/crates/submilli-engine/tests/fixtures/expect_error_date_now.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_date_now.subm rename to crates/submilli-engine/tests/fixtures/expect_error_date_now.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_date_type.subm b/crates/submilli-engine/tests/fixtures/expect_error_date_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_date_type.subm rename to crates/submilli-engine/tests/fixtures/expect_error_date_type.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_default_parameter_before_required_arity.ts b/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_before_required_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_default_parameter_before_required_arity.ts rename to crates/submilli-engine/tests/fixtures/expect_error_default_parameter_before_required_arity.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_default_parameter_iife_tdz.ts b/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_iife_tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_default_parameter_iife_tdz.ts rename to crates/submilli-engine/tests/fixtures/expect_error_default_parameter_iife_tdz.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_default_parameter_invalid_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_invalid_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_default_parameter_invalid_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_default_parameter_invalid_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_defaulted_before_required_signature.ts b/crates/submilli-engine/tests/fixtures/expect_error_defaulted_before_required_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_defaulted_before_required_signature.ts rename to crates/submilli-engine/tests/fixtures/expect_error_defaulted_before_required_signature.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_delete_unsupported.ts b/crates/submilli-engine/tests/fixtures/expect_error_delete_unsupported.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_delete_unsupported.ts rename to crates/submilli-engine/tests/fixtures/expect_error_delete_unsupported.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_destructuring_flow_reset.ts b/crates/submilli-engine/tests/fixtures/expect_error_destructuring_flow_reset.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_destructuring_flow_reset.ts rename to crates/submilli-engine/tests/fixtures/expect_error_destructuring_flow_reset.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_destructuring_source_flow_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_destructuring_source_flow_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_destructuring_source_flow_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_destructuring_source_flow_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts b/crates/submilli-engine/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts rename to crates/submilli-engine/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_do_while_condition_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_do_while_condition_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_do_while_condition_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_do_while_condition_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_duplicate_type_parameter.ts b/crates/submilli-engine/tests/fixtures/expect_error_duplicate_type_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_duplicate_type_parameter.ts rename to crates/submilli-engine/tests/fixtures/expect_error_duplicate_type_parameter.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_empty_array_evolving.ts b/crates/submilli-engine/tests/fixtures/expect_error_empty_array_evolving.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_empty_array_evolving.ts rename to crates/submilli-engine/tests/fixtures/expect_error_empty_array_evolving.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_enum_member_type_mismatch.ts b/crates/submilli-engine/tests/fixtures/expect_error_enum_member_type_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_enum_member_type_mismatch.ts rename to crates/submilli-engine/tests/fixtures/expect_error_enum_member_type_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts b/crates/submilli-engine/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts rename to crates/submilli-engine/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_equality_no_overlap.ts b/crates/submilli-engine/tests/fixtures/expect_error_equality_no_overlap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_equality_no_overlap.ts rename to crates/submilli-engine/tests/fixtures/expect_error_equality_no_overlap.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_error_new_method.ts b/crates/submilli-engine/tests/fixtures/expect_error_error_new_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_error_new_method.ts rename to crates/submilli-engine/tests/fixtures/expect_error_error_new_method.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts b/crates/submilli-engine/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exponentiation_asserted.ts b/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_asserted.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exponentiation_asserted.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exponentiation_asserted.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exponentiation_not.ts b/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_not.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exponentiation_not.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exponentiation_not.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exponentiation_plus.ts b/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_plus.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exponentiation_plus.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exponentiation_plus.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exponentiation_typeof.ts b/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_typeof.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exponentiation_typeof.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exponentiation_typeof.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_exponentiation_unary.ts b/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_unary.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_exponentiation_unary.ts rename to crates/submilli-engine/tests/fixtures/expect_error_exponentiation_unary.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_field_does_not_exist.subm b/crates/submilli-engine/tests/fixtures/expect_error_field_does_not_exist.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_field_does_not_exist.subm rename to crates/submilli-engine/tests/fixtures/expect_error_field_does_not_exist.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_arg_contravariant.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_arg_contravariant.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_arg_contravariant.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_arg_contravariant.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_arg_supertype.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_arg_supertype.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_arg_supertype.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_arg_supertype.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_argument_order.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_argument_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_argument_order.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_argument_order.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_method_argument_order.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_method_argument_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_method_argument_order.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_method_argument_order.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_type_argument_variance.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_type_argument_variance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_type_argument_variance.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_type_argument_variance.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_generic_type_size_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_generic_type_size_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_generic_type_size_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_generic_type_size_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_getter_needs_return.ts b/crates/submilli-engine/tests/fixtures/expect_error_getter_needs_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_getter_needs_return.ts rename to crates/submilli-engine/tests/fixtures/expect_error_getter_needs_return.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_getter_without_return_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_getter_without_return_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_getter_without_return_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_getter_without_return_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_if_empty_body.ts b/crates/submilli-engine/tests/fixtures/expect_error_if_empty_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_if_empty_body.ts rename to crates/submilli-engine/tests/fixtures/expect_error_if_empty_body.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts b/crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts rename to crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_inferred_literal_unknown_field.ts b/crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_unknown_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_inferred_literal_unknown_field.ts rename to crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_unknown_field.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_inferred_literal_weak_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_weak_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_inferred_literal_weak_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_weak_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_inferred_type_depth_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_inferred_type_depth_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_inferred_type_depth_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_inferred_type_depth_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_initializer_captured_mutation.ts b/crates/submilli-engine/tests/fixtures/expect_error_initializer_captured_mutation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_initializer_captured_mutation.ts rename to crates/submilli-engine/tests/fixtures/expect_error_initializer_captured_mutation.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_initializer_null.ts b/crates/submilli-engine/tests/fixtures/expect_error_initializer_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_initializer_null.ts rename to crates/submilli-engine/tests/fixtures/expect_error_initializer_null.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_initializer_readonly.ts b/crates/submilli-engine/tests/fixtures/expect_error_initializer_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_initializer_readonly.ts rename to crates/submilli-engine/tests/fixtures/expect_error_initializer_readonly.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_interface_to_string_property.ts b/crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_property.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_interface_to_string_property.ts rename to crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_property.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_interface_to_string_signature.ts b/crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_interface_to_string_signature.ts rename to crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_signature.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_const_assigned.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_const_assigned.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_const_assigned.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_const_assigned.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_namespace_read_directly.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_namespace_read_directly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_namespace_read_directly.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_namespace_read_directly.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_variable_inferred_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_inferred_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_variable_inferred_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_inferred_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_later_module_variable_read_directly.ts b/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_read_directly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_later_module_variable_read_directly.ts rename to crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_read_directly.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_leading_zero_decimal.ts b/crates/submilli-engine/tests/fixtures/expect_error_leading_zero_decimal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_leading_zero_decimal.ts rename to crates/submilli-engine/tests/fixtures/expect_error_leading_zero_decimal.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_legacy_octal_literal.ts b/crates/submilli-engine/tests/fixtures/expect_error_legacy_octal_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_legacy_octal_literal.ts rename to crates/submilli-engine/tests/fixtures/expect_error_legacy_octal_literal.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_literal_type_number_mismatch.subm b/crates/submilli-engine/tests/fixtures/expect_error_literal_type_number_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_literal_type_number_mismatch.subm rename to crates/submilli-engine/tests/fixtures/expect_error_literal_type_number_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_literal_type_string_mismatch.subm b/crates/submilli-engine/tests/fixtures/expect_error_literal_type_string_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_literal_type_string_mismatch.subm rename to crates/submilli-engine/tests/fixtures/expect_error_literal_type_string_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm b/crates/submilli-engine/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm rename to crates/submilli-engine/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_loop_condition_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_loop_condition_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loop_condition_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loop_condition_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_both_sides.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_both_sides.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_both_sides.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_both_sides.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_constant_results.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_constant_results.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_constant_results.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_constant_results.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_equality.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_equality.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_equality.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_parenthesized.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_parenthesized.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_parenthesized.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_parenthesized.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_loose_nullish_void.ts b/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_void.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_loose_nullish_void.ts rename to crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_void.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_lt_on_boolean.subm b/crates/submilli-engine/tests/fixtures/expect_error_lt_on_boolean.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_lt_on_boolean.subm rename to crates/submilli-engine/tests/fixtures/expect_error_lt_on_boolean.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_map_for_each_param_types.ts b/crates/submilli-engine/tests/fixtures/expect_error_map_for_each_param_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_map_for_each_param_types.ts rename to crates/submilli-engine/tests/fixtures/expect_error_map_for_each_param_types.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_name_after_decimal_point.ts b/crates/submilli-engine/tests/fixtures/expect_error_name_after_decimal_point.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_name_after_decimal_point.ts rename to crates/submilli-engine/tests/fixtures/expect_error_name_after_decimal_point.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nan_comparison.ts b/crates/submilli-engine/tests/fixtures/expect_error_nan_comparison.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nan_comparison.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nan_comparison.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_duplicate.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_duplicate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_duplicate.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_duplicate.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_generic.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_generic.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_generic.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_missing_return.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_missing_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_missing_return.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_missing_return.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_outer_narrowing.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_outer_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_outer_narrowing.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_outer_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_reads_local_below.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_reads_local_below.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_reads_local_below.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_reads_local_below.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_reassigned.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_reassigned.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_reassigned.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_reassigned.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_shadows_param.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_shadows_param.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_shadows_param.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_shadows_param.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_this.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_this.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_this.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_this.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_capture.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_capture.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_capture.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_used_through_alias.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_through_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_used_through_alias.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_through_alias.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nested_function_write_before_capture.ts b/crates/submilli-engine/tests/fixtures/expect_error_nested_function_write_before_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nested_function_write_before_capture.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nested_function_write_before_capture.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts b/crates/submilli-engine/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts rename to crates/submilli-engine/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_nullish_mixed_logical.ts b/crates/submilli-engine/tests/fixtures/expect_error_nullish_mixed_logical.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_nullish_mixed_logical.ts rename to crates/submilli-engine/tests/fixtures/expect_error_nullish_mixed_logical.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_number_plus_string_help.ts b/crates/submilli-engine/tests/fixtures/expect_error_number_plus_string_help.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_number_plus_string_help.ts rename to crates/submilli-engine/tests/fixtures/expect_error_number_plus_string_help.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_numeric_separator.ts b/crates/submilli-engine/tests/fixtures/expect_error_numeric_separator.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_numeric_separator.ts rename to crates/submilli-engine/tests/fixtures/expect_error_numeric_separator.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_object_literal_dictionary_union.ts b/crates/submilli-engine/tests/fixtures/expect_error_object_literal_dictionary_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_object_literal_dictionary_union.ts rename to crates/submilli-engine/tests/fixtures/expect_error_object_literal_dictionary_union.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_object_rest_const_assign.ts b/crates/submilli-engine/tests/fixtures/expect_error_object_rest_const_assign.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_object_rest_const_assign.ts rename to crates/submilli-engine/tests/fixtures/expect_error_object_rest_const_assign.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_object_type_construct_signature.ts b/crates/submilli-engine/tests/fixtures/expect_error_object_type_construct_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_object_type_construct_signature.ts rename to crates/submilli-engine/tests/fixtures/expect_error_object_type_construct_signature.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_chain_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_chain_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_chain_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_chain_missing_key.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_missing_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_chain_missing_key.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_chain_missing_key.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_chain_on_namespace.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_on_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_chain_on_namespace.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_chain_on_namespace.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_chain_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_chain_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_chain_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_method_body_direct_call.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_direct_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_method_body_direct_call.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_direct_call.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_method_super_direct_call.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_method_super_direct_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_method_super_direct_call.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_method_super_direct_call.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_null_field_into_optional.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_null_field_into_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_null_field_into_optional.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_null_field_into_optional.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_optional_parameter_default.ts b/crates/submilli-engine/tests/fixtures/expect_error_optional_parameter_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_optional_parameter_default.ts rename to crates/submilli-engine/tests/fixtures/expect_error_optional_parameter_default.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_parameter_modifier_line_break.ts b/crates/submilli-engine/tests/fixtures/expect_error_parameter_modifier_line_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_parameter_modifier_line_break.ts rename to crates/submilli-engine/tests/fixtures/expect_error_parameter_modifier_line_break.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_parameterless_index_signature.ts b/crates/submilli-engine/tests/fixtures/expect_error_parameterless_index_signature.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_parameterless_index_signature.ts rename to crates/submilli-engine/tests/fixtures/expect_error_parameterless_index_signature.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts b/crates/submilli-engine/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts rename to crates/submilli-engine/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_cast_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_cast_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_cast_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_cast_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_constructor.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_constructor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_constructor.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_constructor.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_line_break_class_member.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_class_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_line_break_class_member.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_class_member.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_line_break_type_member.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_type_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_line_break_type_member.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_type_member.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_readonly_method.ts b/crates/submilli-engine/tests/fixtures/expect_error_readonly_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_readonly_method.ts rename to crates/submilli-engine/tests/fixtures/expect_error_readonly_method.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_backreference.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_backreference.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_backreference.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_backreference.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_duplicate_flag.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_duplicate_flag.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_duplicate_flag.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_duplicate_flag.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_invalid_flag.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_flag.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_invalid_flag.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_flag.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_invalid_pattern.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_pattern.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_invalid_pattern.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_pattern.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_lookahead.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_lookahead.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_lookahead.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_lookahead.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_lookbehind.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_lookbehind.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_lookbehind.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_lookbehind.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_named_backref.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_named_backref.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_named_backref.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_named_backref.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_negative_lookahead.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookahead.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_negative_lookahead.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookahead.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_negative_lookbehind.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookbehind.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_negative_lookbehind.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookbehind.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_regex_unterminated.subm b/crates/submilli-engine/tests/fixtures/expect_error_regex_unterminated.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_regex_unterminated.subm rename to crates/submilli-engine/tests/fixtures/expect_error_regex_unterminated.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_required_parameter_after_optional.ts b/crates/submilli-engine/tests/fixtures/expect_error_required_parameter_after_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_required_parameter_after_optional.ts rename to crates/submilli-engine/tests/fixtures/expect_error_required_parameter_after_optional.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_arity_too_few.subm b/crates/submilli-engine/tests/fixtures/expect_error_rest_arity_too_few.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_arity_too_few.subm rename to crates/submilli-engine/tests/fixtures/expect_error_rest_arity_too_few.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts b/crates/submilli-engine/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts rename to crates/submilli-engine/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_no_annotation.subm b/crates/submilli-engine/tests/fixtures/expect_error_rest_no_annotation.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_no_annotation.subm rename to crates/submilli-engine/tests/fixtures/expect_error_rest_no_annotation.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_non_array.subm b/crates/submilli-engine/tests/fixtures/expect_error_rest_non_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_non_array.subm rename to crates/submilli-engine/tests/fixtures/expect_error_rest_non_array.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_not_last.subm b/crates/submilli-engine/tests/fixtures/expect_error_rest_not_last.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_not_last.subm rename to crates/submilli-engine/tests/fixtures/expect_error_rest_not_last.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_rest_with_default.subm b/crates/submilli-engine/tests/fixtures/expect_error_rest_with_default.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_rest_with_default.subm rename to crates/submilli-engine/tests/fixtures/expect_error_rest_with_default.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_runtime_check_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_runtime_check_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_runtime_check_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_runtime_check_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_runtime_check_locals_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_runtime_check_locals_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_runtime_check_locals_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_runtime_check_locals_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_fallback_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_fallback_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_fallback_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_fallback_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_field_mismatches_interface.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_field_mismatches_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_field_mismatches_interface.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_field_mismatches_interface.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_null.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_null.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_null.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_optional_into_required.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_optional_into_required.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_optional_into_required.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_optional_into_required.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_overwrites_union_tag.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_overwrites_union_tag.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_overwrites_union_tag.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_overwrites_union_tag.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_spread_union_may_be_empty.ts b/crates/submilli-engine/tests/fixtures/expect_error_spread_union_may_be_empty.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_spread_union_may_be_empty.ts rename to crates/submilli-engine/tests/fixtures/expect_error_spread_union_may_be_empty.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_strict_mode_reserved_binding.ts b/crates/submilli-engine/tests/fixtures/expect_error_strict_mode_reserved_binding.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_strict_mode_reserved_binding.ts rename to crates/submilli-engine/tests/fixtures/expect_error_strict_mode_reserved_binding.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_string_at_unnarrowed.ts b/crates/submilli-engine/tests/fixtures/expect_error_string_at_unnarrowed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_string_at_unnarrowed.ts rename to crates/submilli-engine/tests/fixtures/expect_error_string_at_unnarrowed.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_string_or_array_union_method_argument.ts b/crates/submilli-engine/tests/fixtures/expect_error_string_or_array_union_method_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_string_or_array_union_method_argument.ts rename to crates/submilli-engine/tests/fixtures/expect_error_string_or_array_union_method_argument.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_string_plus_number_help.ts b/crates/submilli-engine/tests/fixtures/expect_error_string_plus_number_help.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_string_plus_number_help.ts rename to crates/submilli-engine/tests/fixtures/expect_error_string_plus_number_help.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_string_unknown_method.subm b/crates/submilli-engine/tests/fixtures/expect_error_string_unknown_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_string_unknown_method.subm rename to crates/submilli-engine/tests/fixtures/expect_error_string_unknown_method.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_super_conditional.ts b/crates/submilli-engine/tests/fixtures/expect_error_super_conditional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_super_conditional.ts rename to crates/submilli-engine/tests/fixtures/expect_error_super_conditional.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_super_in_function_expression.ts b/crates/submilli-engine/tests/fixtures/expect_error_super_in_function_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_super_in_function_expression.ts rename to crates/submilli-engine/tests/fixtures/expect_error_super_in_function_expression.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_super_in_nested_function.ts b/crates/submilli-engine/tests/fixtures/expect_error_super_in_nested_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_super_in_nested_function.ts rename to crates/submilli-engine/tests/fixtures/expect_error_super_in_nested_function.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_super_misplaced.ts b/crates/submilli-engine/tests/fixtures/expect_error_super_misplaced.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_super_misplaced.ts rename to crates/submilli-engine/tests/fixtures/expect_error_super_misplaced.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_super_reads_before_call.ts b/crates/submilli-engine/tests/fixtures/expect_error_super_reads_before_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_super_reads_before_call.ts rename to crates/submilli-engine/tests/fixtures/expect_error_super_reads_before_call.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_const.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_const.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_const.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_const.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_function.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_function.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_function.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts b/crates/submilli-engine/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts rename to crates/submilli-engine/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_syntax_nesting_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_syntax_nesting_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_syntax_nesting_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_syntax_nesting_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_template_nesting_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_template_nesting_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_template_nesting_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_template_nesting_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts b/crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts rename to crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts b/crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts rename to crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_this_in_unbound_function_expression.ts b/crates/submilli-engine/tests/fixtures/expect_error_this_in_unbound_function_expression.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_this_in_unbound_function_expression.ts rename to crates/submilli-engine/tests/fixtures/expect_error_this_in_unbound_function_expression.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_tostring_wrong_signature.subm b/crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_signature.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tostring_wrong_signature.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_signature.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tostring_wrong_type.subm b/crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tostring_wrong_type.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_type.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_arity_mismatch.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_arity_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_arity_mismatch.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_arity_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_element_type.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_element_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_element_type.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_element_type.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_empty_rejected.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_empty_rejected.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_empty_rejected.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_empty_rejected.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_index_non_literal.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_index_non_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_index_non_literal.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_index_non_literal.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_index_oob.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_index_oob.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_index_oob.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_index_oob.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_mutators.ts b/crates/submilli-engine/tests/fixtures/expect_error_tuple_mutators.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_mutators.ts rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_mutators.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_optional_rest_elements.ts b/crates/submilli-engine/tests/fixtures/expect_error_tuple_optional_rest_elements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_optional_rest_elements.ts rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_optional_rest_elements.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_push.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_push.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_push.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_push.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_tuple_sort.subm b/crates/submilli-engine/tests/fixtures/expect_error_tuple_sort.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_tuple_sort.subm rename to crates/submilli-engine/tests/fixtures/expect_error_tuple_sort.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_type_args_after_line_break.ts b/crates/submilli-engine/tests/fixtures/expect_error_type_args_after_line_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_args_after_line_break.ts rename to crates/submilli-engine/tests/fixtures/expect_error_type_args_after_line_break.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts b/crates/submilli-engine/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts rename to crates/submilli-engine/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_type_mismatch.subm b/crates/submilli-engine/tests/fixtures/expect_error_type_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_mismatch.subm rename to crates/submilli-engine/tests/fixtures/expect_error_type_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_type_nesting_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_type_nesting_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_nesting_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_type_nesting_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts b/crates/submilli-engine/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts rename to crates/submilli-engine/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_type_size_limit.ts b/crates/submilli-engine/tests/fixtures/expect_error_type_size_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_type_size_limit.ts rename to crates/submilli-engine/tests/fixtures/expect_error_type_size_limit.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_typeof_invalid_tag.subm b/crates/submilli-engine/tests/fixtures/expect_error_typeof_invalid_tag.subm similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_typeof_invalid_tag.subm rename to crates/submilli-engine/tests/fixtures/expect_error_typeof_invalid_tag.subm diff --git a/crates/interpreter/tests/fixtures/expect_error_typeof_of_a_type_name.ts b/crates/submilli-engine/tests/fixtures/expect_error_typeof_of_a_type_name.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_typeof_of_a_type_name.ts rename to crates/submilli-engine/tests/fixtures/expect_error_typeof_of_a_type_name.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_typeof_unknown_value.ts b/crates/submilli-engine/tests/fixtures/expect_error_typeof_unknown_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_typeof_unknown_value.ts rename to crates/submilli-engine/tests/fixtures/expect_error_typeof_unknown_value.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_unary_minus_string.ts b/crates/submilli-engine/tests/fixtures/expect_error_unary_minus_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_unary_minus_string.ts rename to crates/submilli-engine/tests/fixtures/expect_error_unary_minus_string.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_unary_plus_nullable_string.ts b/crates/submilli-engine/tests/fixtures/expect_error_unary_plus_nullable_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_unary_plus_nullable_string.ts rename to crates/submilli-engine/tests/fixtures/expect_error_unary_plus_nullable_string.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts b/crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts rename to crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_export.ts b/crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_export.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_export.ts rename to crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_export.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts b/crates/submilli-engine/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts rename to crates/submilli-engine/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts b/crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts rename to crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts b/crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts rename to crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required.ts b/crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required.ts rename to crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts b/crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts rename to crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_union_literal_assignment_only.ts b/crates/submilli-engine/tests/fixtures/expect_error_union_literal_assignment_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_union_literal_assignment_only.ts rename to crates/submilli-engine/tests/fixtures/expect_error_union_literal_assignment_only.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field.ts b/crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field.ts rename to crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts b/crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts rename to crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_visibility_after_readonly.ts b/crates/submilli-engine/tests/fixtures/expect_error_visibility_after_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_visibility_after_readonly.ts rename to crates/submilli-engine/tests/fixtures/expect_error_visibility_after_readonly.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_void_compared_with_value.ts b/crates/submilli-engine/tests/fixtures/expect_error_void_compared_with_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_void_compared_with_value.ts rename to crates/submilli-engine/tests/fixtures/expect_error_void_compared_with_value.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_void_condition.ts b/crates/submilli-engine/tests/fixtures/expect_error_void_condition.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_void_condition.ts rename to crates/submilli-engine/tests/fixtures/expect_error_void_condition.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_void_conditional_into_value_slot.ts b/crates/submilli-engine/tests/fixtures/expect_error_void_conditional_into_value_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_void_conditional_into_value_slot.ts rename to crates/submilli-engine/tests/fixtures/expect_error_void_conditional_into_value_slot.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts b/crates/submilli-engine/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts rename to crates/submilli-engine/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts diff --git a/crates/interpreter/tests/fixtures/expect_error_weak_type_no_common_field.ts b/crates/submilli-engine/tests/fixtures/expect_error_weak_type_no_common_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_error_weak_type_no_common_field.ts rename to crates/submilli-engine/tests/fixtures/expect_error_weak_type_no_common_field.ts diff --git a/crates/interpreter/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts b/crates/submilli-engine/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts rename to crates/submilli-engine/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts diff --git a/crates/interpreter/tests/fixtures/exponentiation_grouping.ts b/crates/submilli-engine/tests/fixtures/exponentiation_grouping.ts similarity index 100% rename from crates/interpreter/tests/fixtures/exponentiation_grouping.ts rename to crates/submilli-engine/tests/fixtures/exponentiation_grouping.ts diff --git a/crates/interpreter/tests/fixtures/field_assignment_flow.ts b/crates/submilli-engine/tests/fixtures/field_assignment_flow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/field_assignment_flow.ts rename to crates/submilli-engine/tests/fixtures/field_assignment_flow.ts diff --git a/crates/interpreter/tests/fixtures/for_of_string_or_array.ts b/crates/submilli-engine/tests/fixtures/for_of_string_or_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/for_of_string_or_array.ts rename to crates/submilli-engine/tests/fixtures/for_of_string_or_array.ts diff --git a/crates/interpreter/tests/fixtures/fs/absence_probing.ts b/crates/submilli-engine/tests/fixtures/fs/absence_probing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/absence_probing.ts rename to crates/submilli-engine/tests/fixtures/fs/absence_probing.ts diff --git a/crates/interpreter/tests/fixtures/fs/append_text.subm b/crates/submilli-engine/tests/fixtures/fs/append_text.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/append_text.subm rename to crates/submilli-engine/tests/fixtures/fs/append_text.subm diff --git a/crates/interpreter/tests/fixtures/fs/bytes_iteration.subm b/crates/submilli-engine/tests/fixtures/fs/bytes_iteration.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/bytes_iteration.subm rename to crates/submilli-engine/tests/fixtures/fs/bytes_iteration.subm diff --git a/crates/interpreter/tests/fixtures/fs/bytes_write_read.subm b/crates/submilli-engine/tests/fixtures/fs/bytes_write_read.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/bytes_write_read.subm rename to crates/submilli-engine/tests/fixtures/fs/bytes_write_read.subm diff --git a/crates/interpreter/tests/fixtures/fs/copy_creates_destination_parents.ts b/crates/submilli-engine/tests/fixtures/fs/copy_creates_destination_parents.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/copy_creates_destination_parents.ts rename to crates/submilli-engine/tests/fixtures/fs/copy_creates_destination_parents.ts diff --git a/crates/interpreter/tests/fixtures/fs/cwd.ts b/crates/submilli-engine/tests/fixtures/fs/cwd.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/cwd.ts rename to crates/submilli-engine/tests/fixtures/fs/cwd.ts diff --git a/crates/interpreter/tests/fixtures/fs/exists_size.subm b/crates/submilli-engine/tests/fixtures/fs/exists_size.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/exists_size.subm rename to crates/submilli-engine/tests/fixtures/fs/exists_size.subm diff --git a/crates/interpreter/tests/fixtures/fs/info_basic.subm b/crates/submilli-engine/tests/fixtures/fs/info_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/info_basic.subm rename to crates/submilli-engine/tests/fixtures/fs/info_basic.subm diff --git a/crates/interpreter/tests/fixtures/fs/linear_remove_move.ts b/crates/submilli-engine/tests/fixtures/fs/linear_remove_move.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/linear_remove_move.ts rename to crates/submilli-engine/tests/fixtures/fs/linear_remove_move.ts diff --git a/crates/interpreter/tests/fixtures/fs/lines_break.subm b/crates/submilli-engine/tests/fixtures/fs/lines_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/lines_break.subm rename to crates/submilli-engine/tests/fixtures/fs/lines_break.subm diff --git a/crates/interpreter/tests/fixtures/fs/lines_iteration.subm b/crates/submilli-engine/tests/fixtures/fs/lines_iteration.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/lines_iteration.subm rename to crates/submilli-engine/tests/fixtures/fs/lines_iteration.subm diff --git a/crates/interpreter/tests/fixtures/fs/list_deep.ts b/crates/submilli-engine/tests/fixtures/fs/list_deep.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/list_deep.ts rename to crates/submilli-engine/tests/fixtures/fs/list_deep.ts diff --git a/crates/interpreter/tests/fixtures/fs/list_entry_shape.ts b/crates/submilli-engine/tests/fixtures/fs/list_entry_shape.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/list_entry_shape.ts rename to crates/submilli-engine/tests/fixtures/fs/list_entry_shape.ts diff --git a/crates/interpreter/tests/fixtures/fs/list_flat.subm b/crates/submilli-engine/tests/fixtures/fs/list_flat.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/list_flat.subm rename to crates/submilli-engine/tests/fixtures/fs/list_flat.subm diff --git a/crates/interpreter/tests/fixtures/fs/list_recursive.subm b/crates/submilli-engine/tests/fixtures/fs/list_recursive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/list_recursive.subm rename to crates/submilli-engine/tests/fixtures/fs/list_recursive.subm diff --git a/crates/interpreter/tests/fixtures/fs/many_handles_recovered.subm b/crates/submilli-engine/tests/fixtures/fs/many_handles_recovered.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/many_handles_recovered.subm rename to crates/submilli-engine/tests/fixtures/fs/many_handles_recovered.subm diff --git a/crates/interpreter/tests/fixtures/fs/max_read_size.subm b/crates/submilli-engine/tests/fixtures/fs/max_read_size.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/max_read_size.subm rename to crates/submilli-engine/tests/fixtures/fs/max_read_size.subm diff --git a/crates/interpreter/tests/fixtures/fs/mkdir_nested.subm b/crates/submilli-engine/tests/fixtures/fs/mkdir_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/mkdir_nested.subm rename to crates/submilli-engine/tests/fixtures/fs/mkdir_nested.subm diff --git a/crates/interpreter/tests/fixtures/fs/move_copy_remove.subm b/crates/submilli-engine/tests/fixtures/fs/move_copy_remove.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/move_copy_remove.subm rename to crates/submilli-engine/tests/fixtures/fs/move_copy_remove.subm diff --git a/crates/interpreter/tests/fixtures/fs/peek_basic.subm b/crates/submilli-engine/tests/fixtures/fs/peek_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/peek_basic.subm rename to crates/submilli-engine/tests/fixtures/fs/peek_basic.subm diff --git a/crates/interpreter/tests/fixtures/fs/peek_crlf.subm b/crates/submilli-engine/tests/fixtures/fs/peek_crlf.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/peek_crlf.subm rename to crates/submilli-engine/tests/fixtures/fs/peek_crlf.subm diff --git a/crates/interpreter/tests/fixtures/fs/read_bytes_range.subm b/crates/submilli-engine/tests/fixtures/fs/read_bytes_range.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/read_bytes_range.subm rename to crates/submilli-engine/tests/fixtures/fs/read_bytes_range.subm diff --git a/crates/interpreter/tests/fixtures/fs/remove_recursive.subm b/crates/submilli-engine/tests/fixtures/fs/remove_recursive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/remove_recursive.subm rename to crates/submilli-engine/tests/fixtures/fs/remove_recursive.subm diff --git a/crates/interpreter/tests/fixtures/fs/root_is_not_a_target.ts b/crates/submilli-engine/tests/fixtures/fs/root_is_not_a_target.ts similarity index 100% rename from crates/interpreter/tests/fixtures/fs/root_is_not_a_target.ts rename to crates/submilli-engine/tests/fixtures/fs/root_is_not_a_target.ts diff --git a/crates/interpreter/tests/fixtures/fs/stat_kinds.subm b/crates/submilli-engine/tests/fixtures/fs/stat_kinds.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/stat_kinds.subm rename to crates/submilli-engine/tests/fixtures/fs/stat_kinds.subm diff --git a/crates/interpreter/tests/fixtures/fs/text_write_read.subm b/crates/submilli-engine/tests/fixtures/fs/text_write_read.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/text_write_read.subm rename to crates/submilli-engine/tests/fixtures/fs/text_write_read.subm diff --git a/crates/interpreter/tests/fixtures/fs/writer_basic.subm b/crates/submilli-engine/tests/fixtures/fs/writer_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/writer_basic.subm rename to crates/submilli-engine/tests/fixtures/fs/writer_basic.subm diff --git a/crates/interpreter/tests/fixtures/fs/writer_bytes.subm b/crates/submilli-engine/tests/fixtures/fs/writer_bytes.subm similarity index 100% rename from crates/interpreter/tests/fixtures/fs/writer_bytes.subm rename to crates/submilli-engine/tests/fixtures/fs/writer_bytes.subm diff --git a/crates/interpreter/tests/fixtures/function_as_value.subm b/crates/submilli-engine/tests/fixtures/function_as_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/function_as_value.subm rename to crates/submilli-engine/tests/fixtures/function_as_value.subm diff --git a/crates/interpreter/tests/fixtures/function_identity_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/function_identity_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_identity_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/function_identity_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/function_identity_cross_package/lib/extra.ts b/crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/extra.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_identity_cross_package/lib/extra.ts rename to crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/extra.ts diff --git a/crates/interpreter/tests/fixtures/function_identity_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_identity_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/function_identity_cross_package/mid/lib.ts b/crates/submilli-engine/tests/fixtures/function_identity_cross_package/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_identity_cross_package/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/function_identity_cross_package/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/function_identity_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/function_identity_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/function_identity_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/function_identity_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/function_type_rendering_round_trip.ts b/crates/submilli-engine/tests/fixtures/function_type_rendering_round_trip.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_type_rendering_round_trip.ts rename to crates/submilli-engine/tests/fixtures/function_type_rendering_round_trip.ts diff --git a/crates/interpreter/tests/fixtures/function_type_renders_parseable.ts b/crates/submilli-engine/tests/fixtures/function_type_renders_parseable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_type_renders_parseable.ts rename to crates/submilli-engine/tests/fixtures/function_type_renders_parseable.ts diff --git a/crates/interpreter/tests/fixtures/function_typed_array_elements.ts b/crates/submilli-engine/tests/fixtures/function_typed_array_elements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/function_typed_array_elements.ts rename to crates/submilli-engine/tests/fixtures/function_typed_array_elements.ts diff --git a/crates/interpreter/tests/fixtures/generic_arg_accepts_subclass.ts b/crates/submilli-engine/tests/fixtures/generic_arg_accepts_subclass.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generic_arg_accepts_subclass.ts rename to crates/submilli-engine/tests/fixtures/generic_arg_accepts_subclass.ts diff --git a/crates/interpreter/tests/fixtures/generic_call_infers_common_supertype.ts b/crates/submilli-engine/tests/fixtures/generic_call_infers_common_supertype.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generic_call_infers_common_supertype.ts rename to crates/submilli-engine/tests/fixtures/generic_call_infers_common_supertype.ts diff --git a/crates/interpreter/tests/fixtures/generic_call_infers_from_expected_union.ts b/crates/submilli-engine/tests/fixtures/generic_call_infers_from_expected_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generic_call_infers_from_expected_union.ts rename to crates/submilli-engine/tests/fixtures/generic_call_infers_from_expected_union.ts diff --git a/crates/interpreter/tests/fixtures/generic_type_argument_variance.ts b/crates/submilli-engine/tests/fixtures/generic_type_argument_variance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generic_type_argument_variance.ts rename to crates/submilli-engine/tests/fixtures/generic_type_argument_variance.ts diff --git a/crates/interpreter/tests/fixtures/generics/array_push_aliased_function.subm b/crates/submilli-engine/tests/fixtures/generics/array_push_aliased_function.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/array_push_aliased_function.subm rename to crates/submilli-engine/tests/fixtures/generics/array_push_aliased_function.subm diff --git a/crates/interpreter/tests/fixtures/generics/array_sort_aliased_object.subm b/crates/submilli-engine/tests/fixtures/generics/array_sort_aliased_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/array_sort_aliased_object.subm rename to crates/submilli-engine/tests/fixtures/generics/array_sort_aliased_object.subm diff --git a/crates/interpreter/tests/fixtures/generics/call_void_return_type_arg.ts b/crates/submilli-engine/tests/fixtures/generics/call_void_return_type_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/call_void_return_type_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/call_void_return_type_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/callback_parameter_wider_than_element.ts b/crates/submilli-engine/tests/fixtures/generics/callback_parameter_wider_than_element.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/callback_parameter_wider_than_element.ts rename to crates/submilli-engine/tests/fixtures/generics/callback_parameter_wider_than_element.ts diff --git a/crates/interpreter/tests/fixtures/generics/captured_typevar_union_boxed.ts b/crates/submilli-engine/tests/fixtures/generics/captured_typevar_union_boxed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/captured_typevar_union_boxed.ts rename to crates/submilli-engine/tests/fixtures/generics/captured_typevar_union_boxed.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_box_basic.ts b/crates/submilli-engine/tests/fixtures/generics/class_box_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_box_basic.ts rename to crates/submilli-engine/tests/fixtures/generics/class_box_basic.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_closure_typed_field.ts b/crates/submilli-engine/tests/fixtures/generics/class_closure_typed_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_closure_typed_field.ts rename to crates/submilli-engine/tests/fixtures/generics/class_closure_typed_field.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package/boxes/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package/boxes/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package/boxes/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package/boxes/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_chain/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_chain/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_interface/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_interface/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/app/main.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/app/main.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/app/main.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/packages.manifest b/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/packages.manifest rename to crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/packages.manifest diff --git a/crates/interpreter/tests/fixtures/generics/class_erased_slot_abi.ts b/crates/submilli-engine/tests/fixtures/generics/class_erased_slot_abi.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_erased_slot_abi.ts rename to crates/submilli-engine/tests/fixtures/generics/class_erased_slot_abi.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_error_subclass.ts b/crates/submilli-engine/tests/fixtures/generics/class_error_subclass.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_error_subclass.ts rename to crates/submilli-engine/tests/fixtures/generics/class_error_subclass.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_extends_concrete_args.ts b/crates/submilli-engine/tests/fixtures/generics/class_extends_concrete_args.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_extends_concrete_args.ts rename to crates/submilli-engine/tests/fixtures/generics/class_extends_concrete_args.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_generic_extends_generic.ts b/crates/submilli-engine/tests/fixtures/generics/class_generic_extends_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_generic_extends_generic.ts rename to crates/submilli-engine/tests/fixtures/generics/class_generic_extends_generic.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_generic_field_rw.ts b/crates/submilli-engine/tests/fixtures/generics/class_generic_field_rw.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_generic_field_rw.ts rename to crates/submilli-engine/tests/fixtures/generics/class_generic_field_rw.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_implements_generic_interface.ts b/crates/submilli-engine/tests/fixtures/generics/class_implements_generic_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_implements_generic_interface.ts rename to crates/submilli-engine/tests/fixtures/generics/class_implements_generic_interface.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_infer_void_arg.ts b/crates/submilli-engine/tests/fixtures/generics/class_infer_void_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_infer_void_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/class_infer_void_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_instanceof.ts b/crates/submilli-engine/tests/fixtures/generics/class_instanceof.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_instanceof.ts rename to crates/submilli-engine/tests/fixtures/generics/class_instanceof.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_instanceof_subclass.ts b/crates/submilli-engine/tests/fixtures/generics/class_instanceof_subclass.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_instanceof_subclass.ts rename to crates/submilli-engine/tests/fixtures/generics/class_instanceof_subclass.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_object_literal_in_closure.ts b/crates/submilli-engine/tests/fixtures/generics/class_object_literal_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_object_literal_in_closure.ts rename to crates/submilli-engine/tests/fixtures/generics/class_object_literal_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_recursive_node.ts b/crates/submilli-engine/tests/fixtures/generics/class_recursive_node.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_recursive_node.ts rename to crates/submilli-engine/tests/fixtures/generics/class_recursive_node.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_statics_optional_readonly.ts b/crates/submilli-engine/tests/fixtures/generics/class_statics_optional_readonly.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_statics_optional_readonly.ts rename to crates/submilli-engine/tests/fixtures/generics/class_statics_optional_readonly.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_this_in_closure.ts b/crates/submilli-engine/tests/fixtures/generics/class_this_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_this_in_closure.ts rename to crates/submilli-engine/tests/fixtures/generics/class_this_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_two_params.ts b/crates/submilli-engine/tests/fixtures/generics/class_two_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_two_params.ts rename to crates/submilli-engine/tests/fixtures/generics/class_two_params.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_type_arg_shapes.ts b/crates/submilli-engine/tests/fixtures/generics/class_type_arg_shapes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_type_arg_shapes.ts rename to crates/submilli-engine/tests/fixtures/generics/class_type_arg_shapes.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts b/crates/submilli-engine/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts rename to crates/submilli-engine/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_union_narrowing.ts b/crates/submilli-engine/tests/fixtures/generics/class_union_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_union_narrowing.ts rename to crates/submilli-engine/tests/fixtures/generics/class_union_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_universal_slots.ts b/crates/submilli-engine/tests/fixtures/generics/class_universal_slots.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_universal_slots.ts rename to crates/submilli-engine/tests/fixtures/generics/class_universal_slots.ts diff --git a/crates/interpreter/tests/fixtures/generics/class_void_type_arg.ts b/crates/submilli-engine/tests/fixtures/generics/class_void_type_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/class_void_type_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/class_void_type_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_arithmetic_on_t.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_arithmetic_on_t.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_arithmetic_on_t.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_arithmetic_on_t.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_arity_mismatch.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_arity_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_arity_mismatch.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_arity_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_arg_mismatch.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_arg_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_arg_mismatch.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_arg_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_extends_arity.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_extends_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_extends_arity.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_extends_arity.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_generic_arity.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_generic_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_generic_arity.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_generic_arity.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_alias.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_alias.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_alias.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_args.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_args.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_args.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_args.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_method_generic.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_method_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_method_generic.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_method_generic.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_never_type_arg.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_never_type_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_never_type_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_never_type_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_class_static_type_param.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_class_static_type_param.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_class_static_type_param.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_class_static_type_param.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_conflicting_bindings.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_conflicting_bindings.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_conflicting_bindings.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_conflicting_bindings.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_cross_gp_assignment.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_cross_gp_assignment.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_cross_gp_assignment.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_cross_gp_assignment.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_first_class_generic.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_first_class_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_first_class_generic.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_first_class_generic.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_inference_argument_priority.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_inference_argument_priority.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_inference_argument_priority.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_inference_argument_priority.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_interface_arity.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_interface_arity.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_interface_arity.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_interface_arity.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_method_never_type_arg.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_method_never_type_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_method_never_type_arg.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_method_never_type_arg.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm b/crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm rename to crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts diff --git a/crates/interpreter/tests/fixtures/generics/expect_error_union_member_closely_matched.ts b/crates/submilli-engine/tests/fixtures/generics/expect_error_union_member_closely_matched.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/expect_error_union_member_closely_matched.ts rename to crates/submilli-engine/tests/fixtures/generics/expect_error_union_member_closely_matched.ts diff --git a/crates/interpreter/tests/fixtures/generics/explicit_type_args.subm b/crates/submilli-engine/tests/fixtures/generics/explicit_type_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/explicit_type_args.subm rename to crates/submilli-engine/tests/fixtures/generics/explicit_type_args.subm diff --git a/crates/interpreter/tests/fixtures/generics/first.subm b/crates/submilli-engine/tests/fixtures/generics/first.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/first.subm rename to crates/submilli-engine/tests/fixtures/generics/first.subm diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_keeps_literal_type.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_keeps_literal_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_keeps_literal_type.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_keeps_literal_type.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_nested_literal_arguments.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_nested_literal_arguments.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_nested_literal_arguments.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_nested_literal_arguments.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_call_widens_fresh_literal.ts b/crates/submilli-engine/tests/fixtures/generics/generic_call_widens_fresh_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_call_widens_fresh_literal.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_call_widens_fresh_literal.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_calls_generic.subm b/crates/submilli-engine/tests/fixtures/generics/generic_calls_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_calls_generic.subm rename to crates/submilli-engine/tests/fixtures/generics/generic_calls_generic.subm diff --git a/crates/interpreter/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts b/crates/submilli-engine/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_interface_annotation.subm b/crates/submilli-engine/tests/fixtures/generics/generic_interface_annotation.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_interface_annotation.subm rename to crates/submilli-engine/tests/fixtures/generics/generic_interface_annotation.subm diff --git a/crates/interpreter/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts b/crates/submilli-engine/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_object_round_trip.subm b/crates/submilli-engine/tests/fixtures/generics/generic_object_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_object_round_trip.subm rename to crates/submilli-engine/tests/fixtures/generics/generic_object_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/generics/generic_recursion.subm b/crates/submilli-engine/tests/fixtures/generics/generic_recursion.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_recursion.subm rename to crates/submilli-engine/tests/fixtures/generics/generic_recursion.subm diff --git a/crates/interpreter/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts b/crates/submilli-engine/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts b/crates/submilli-engine/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts b/crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_union_parameter_naked_priority.ts b/crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_naked_priority.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_union_parameter_naked_priority.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_naked_priority.ts diff --git a/crates/interpreter/tests/fixtures/generics/generic_variance_measured_once.ts b/crates/submilli-engine/tests/fixtures/generics/generic_variance_measured_once.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/generic_variance_measured_once.ts rename to crates/submilli-engine/tests/fixtures/generics/generic_variance_measured_once.ts diff --git a/crates/interpreter/tests/fixtures/generics/identity.subm b/crates/submilli-engine/tests/fixtures/generics/identity.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/identity.subm rename to crates/submilli-engine/tests/fixtures/generics/identity.subm diff --git a/crates/interpreter/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts b/crates/submilli-engine/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts rename to crates/submilli-engine/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts diff --git a/crates/interpreter/tests/fixtures/generics/map_set_aliased_value.subm b/crates/submilli-engine/tests/fixtures/generics/map_set_aliased_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/map_set_aliased_value.subm rename to crates/submilli-engine/tests/fixtures/generics/map_set_aliased_value.subm diff --git a/crates/interpreter/tests/fixtures/generics/nullish_candidates_infer_their_union.ts b/crates/submilli-engine/tests/fixtures/generics/nullish_candidates_infer_their_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/nullish_candidates_infer_their_union.ts rename to crates/submilli-engine/tests/fixtures/generics/nullish_candidates_infer_their_union.ts diff --git a/crates/interpreter/tests/fixtures/generics/object_literal_for_generic_interface.ts b/crates/submilli-engine/tests/fixtures/generics/object_literal_for_generic_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/object_literal_for_generic_interface.ts rename to crates/submilli-engine/tests/fixtures/generics/object_literal_for_generic_interface.ts diff --git a/crates/interpreter/tests/fixtures/generics/recursion.subm b/crates/submilli-engine/tests/fixtures/generics/recursion.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/recursion.subm rename to crates/submilli-engine/tests/fixtures/generics/recursion.subm diff --git a/crates/interpreter/tests/fixtures/generics/returns_generic_closure.subm b/crates/submilli-engine/tests/fixtures/generics/returns_generic_closure.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/returns_generic_closure.subm rename to crates/submilli-engine/tests/fixtures/generics/returns_generic_closure.subm diff --git a/crates/interpreter/tests/fixtures/generics/tostring_on_t.subm b/crates/submilli-engine/tests/fixtures/generics/tostring_on_t.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/tostring_on_t.subm rename to crates/submilli-engine/tests/fixtures/generics/tostring_on_t.subm diff --git a/crates/interpreter/tests/fixtures/generics/tuple_return_generic_fn.ts b/crates/submilli-engine/tests/fixtures/generics/tuple_return_generic_fn.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/tuple_return_generic_fn.ts rename to crates/submilli-engine/tests/fixtures/generics/tuple_return_generic_fn.ts diff --git a/crates/interpreter/tests/fixtures/generics/uninferred_type_param_is_unknown.subm b/crates/submilli-engine/tests/fixtures/generics/uninferred_type_param_is_unknown.subm similarity index 100% rename from crates/interpreter/tests/fixtures/generics/uninferred_type_param_is_unknown.subm rename to crates/submilli-engine/tests/fixtures/generics/uninferred_type_param_is_unknown.subm diff --git a/crates/interpreter/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts b/crates/submilli-engine/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts rename to crates/submilli-engine/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts diff --git a/crates/interpreter/tests/fixtures/generics/unknown_runtime_descriptor.ts b/crates/submilli-engine/tests/fixtures/generics/unknown_runtime_descriptor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/generics/unknown_runtime_descriptor.ts rename to crates/submilli-engine/tests/fixtures/generics/unknown_runtime_descriptor.ts diff --git a/crates/interpreter/tests/fixtures/global_array_object_literal.subm b/crates/submilli-engine/tests/fixtures/global_array_object_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/global_array_object_literal.subm rename to crates/submilli-engine/tests/fixtures/global_array_object_literal.subm diff --git a/crates/interpreter/tests/fixtures/higher_order_function.subm b/crates/submilli-engine/tests/fixtures/higher_order_function.subm similarity index 100% rename from crates/interpreter/tests/fixtures/higher_order_function.subm rename to crates/submilli-engine/tests/fixtures/higher_order_function.subm diff --git a/crates/interpreter/tests/fixtures/higher_order_no_literal.ts b/crates/submilli-engine/tests/fixtures/higher_order_no_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/higher_order_no_literal.ts rename to crates/submilli-engine/tests/fixtures/higher_order_no_literal.ts diff --git a/crates/interpreter/tests/fixtures/higher_order_with_capture.subm b/crates/submilli-engine/tests/fixtures/higher_order_with_capture.subm similarity index 100% rename from crates/interpreter/tests/fixtures/higher_order_with_capture.subm rename to crates/submilli-engine/tests/fixtures/higher_order_with_capture.subm diff --git a/crates/interpreter/tests/fixtures/host_error_catchable.subm b/crates/submilli-engine/tests/fixtures/host_error_catchable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/host_error_catchable.subm rename to crates/submilli-engine/tests/fixtures/host_error_catchable.subm diff --git a/crates/interpreter/tests/fixtures/host_held_values_survive_collection.ts b/crates/submilli-engine/tests/fixtures/host_held_values_survive_collection.ts similarity index 100% rename from crates/interpreter/tests/fixtures/host_held_values_survive_collection.ts rename to crates/submilli-engine/tests/fixtures/host_held_values_survive_collection.ts diff --git a/crates/interpreter/tests/fixtures/host_owned_vtables.ts b/crates/submilli-engine/tests/fixtures/host_owned_vtables.ts similarity index 100% rename from crates/interpreter/tests/fixtures/host_owned_vtables.ts rename to crates/submilli-engine/tests/fixtures/host_owned_vtables.ts diff --git a/crates/interpreter/tests/fixtures/host_string_struct_spike.ts b/crates/submilli-engine/tests/fixtures/host_string_struct_spike.ts similarity index 100% rename from crates/interpreter/tests/fixtures/host_string_struct_spike.ts rename to crates/submilli-engine/tests/fixtures/host_string_struct_spike.ts diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_get_too_many_args.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_too_many_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_get_too_many_args.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_too_many_args.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_get_with_body.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_with_body.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_get_with_body.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_with_body.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_method.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_method.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_method.subm diff --git a/crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_property.subm b/crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_property.subm similarity index 100% rename from crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_property.subm rename to crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_property.subm diff --git a/crates/interpreter/tests/fixtures/http_dot_segments.ts b/crates/submilli-engine/tests/fixtures/http_dot_segments.ts similarity index 100% rename from crates/interpreter/tests/fixtures/http_dot_segments.ts rename to crates/submilli-engine/tests/fixtures/http_dot_segments.ts diff --git a/crates/interpreter/tests/fixtures/imports/alias_named_from.ts b/crates/submilli-engine/tests/fixtures/imports/alias_named_from.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/alias_named_from.ts rename to crates/submilli-engine/tests/fixtures/imports/alias_named_from.ts diff --git a/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts b/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts rename to crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts diff --git a/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts b/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest b/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest rename to crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest diff --git a/crates/interpreter/tests/fixtures/imports/embedding_aliased.ts b/crates/submilli-engine/tests/fixtures/imports/embedding_aliased.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/embedding_aliased.ts rename to crates/submilli-engine/tests/fixtures/imports/embedding_aliased.ts diff --git a/crates/interpreter/tests/fixtures/imports/embedding_named.ts b/crates/submilli-engine/tests/fixtures/imports/embedding_named.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/embedding_named.ts rename to crates/submilli-engine/tests/fixtures/imports/embedding_named.ts diff --git a/crates/interpreter/tests/fixtures/imports/embedding_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/embedding_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/embedding_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/embedding_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/embedding_wildcard_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/embedding_wildcard_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/embedding_wildcard_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/embedding_wildcard_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/errors/combined_default_named.subm b/crates/submilli-engine/tests/fixtures/imports/errors/combined_default_named.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/combined_default_named.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/combined_default_named.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/duplicate_local.subm b/crates/submilli-engine/tests/fixtures/imports/errors/duplicate_local.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/duplicate_local.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/duplicate_local.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm b/crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm b/crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/export_default.subm b/crates/submilli-engine/tests/fixtures/imports/errors/export_default.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/export_default.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/export_default.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/export_inside_function_body.subm b/crates/submilli-engine/tests/fixtures/imports/errors/export_inside_function_body.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/export_inside_function_body.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/export_inside_function_body.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/export_list.subm b/crates/submilli-engine/tests/fixtures/imports/errors/export_list.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/export_list.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/export_list.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/import_in_function.subm b/crates/submilli-engine/tests/fixtures/imports/errors/import_in_function.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/import_in_function.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/import_in_function.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/namespace_as_value.subm b/crates/submilli-engine/tests/fixtures/imports/errors/namespace_as_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/namespace_as_value.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/namespace_as_value.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/namespace_member_as_value.subm b/crates/submilli-engine/tests/fixtures/imports/errors/namespace_member_as_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/namespace_member_as_value.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/namespace_member_as_value.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/relative_import_escapes_root.subm b/crates/submilli-engine/tests/fixtures/imports/errors/relative_import_escapes_root.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/relative_import_escapes_root.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/relative_import_escapes_root.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/relative_import_single_file.subm b/crates/submilli-engine/tests/fixtures/imports/errors/relative_import_single_file.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/relative_import_single_file.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/relative_import_single_file.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/unknown_named.subm b/crates/submilli-engine/tests/fixtures/imports/errors/unknown_named.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/unknown_named.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/unknown_named.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/unknown_namespace_member.subm b/crates/submilli-engine/tests/fixtures/imports/errors/unknown_namespace_member.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/unknown_namespace_member.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/unknown_namespace_member.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/unknown_package.subm b/crates/submilli-engine/tests/fixtures/imports/errors/unknown_package.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/unknown_package.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/unknown_package.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm b/crates/submilli-engine/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm diff --git a/crates/interpreter/tests/fixtures/imports/errors/uuid_not_auto_imported.subm b/crates/submilli-engine/tests/fixtures/imports/errors/uuid_not_auto_imported.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/errors/uuid_not_auto_imported.subm rename to crates/submilli-engine/tests/fixtures/imports/errors/uuid_not_auto_imported.subm diff --git a/crates/interpreter/tests/fixtures/imports/export_modifier_ignored.subm b/crates/submilli-engine/tests/fixtures/imports/export_modifier_ignored.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/export_modifier_ignored.subm rename to crates/submilli-engine/tests/fixtures/imports/export_modifier_ignored.subm diff --git a/crates/interpreter/tests/fixtures/imports/http_namespace_optional_args.subm b/crates/submilli-engine/tests/fixtures/imports/http_namespace_optional_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/http_namespace_optional_args.subm rename to crates/submilli-engine/tests/fixtures/imports/http_namespace_optional_args.subm diff --git a/crates/interpreter/tests/fixtures/imports/import_prelude_namespace_forgiven.subm b/crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_forgiven.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/import_prelude_namespace_forgiven.subm rename to crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_forgiven.subm diff --git a/crates/interpreter/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm b/crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm rename to crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm diff --git a/crates/interpreter/tests/fixtures/imports/llm_aliased.ts b/crates/submilli-engine/tests/fixtures/imports/llm_aliased.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_aliased.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_aliased.ts diff --git a/crates/interpreter/tests/fixtures/imports/llm_named.ts b/crates/submilli-engine/tests/fixtures/imports/llm_named.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_named.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_named.ts diff --git a/crates/interpreter/tests/fixtures/imports/llm_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/llm_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/llm_package_caller/app/main.ts b/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_package_caller/app/main.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_package_caller/app/main.ts diff --git a/crates/interpreter/tests/fixtures/imports/llm_package_caller/packages.manifest b/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_package_caller/packages.manifest rename to crates/submilli-engine/tests/fixtures/imports/llm_package_caller/packages.manifest diff --git a/crates/interpreter/tests/fixtures/imports/llm_package_caller/triage/lib.ts b/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/triage/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_package_caller/triage/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_package_caller/triage/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/llm_wildcard_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/llm_wildcard_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/llm_wildcard_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/llm_wildcard_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_basic.subm b/crates/submilli-engine/tests/fixtures/imports/security_check_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_basic.subm rename to crates/submilli-engine/tests/fixtures/imports/security_check_basic.subm diff --git a/crates/interpreter/tests/fixtures/imports/security_check_chain/app/main.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_chain/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_chain/app/main.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_chain/app/main.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_chain/inner/lib.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_chain/inner/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_chain/inner/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_chain/inner/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_chain/outer/lib.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_chain/outer/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_chain/outer/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_chain/outer/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_chain/packages.manifest b/crates/submilli-engine/tests/fixtures/imports/security_check_chain/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_chain/packages.manifest rename to crates/submilli-engine/tests/fixtures/imports/security_check_chain/packages.manifest diff --git a/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/app/main.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_closure_callback/app/main.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/app/main.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/packages.manifest b/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_closure_callback/packages.manifest rename to crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/packages.manifest diff --git a/crates/interpreter/tests/fixtures/imports/security_check_denied.ts b/crates/submilli-engine/tests/fixtures/imports/security_check_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_denied.ts rename to crates/submilli-engine/tests/fixtures/imports/security_check_denied.ts diff --git a/crates/interpreter/tests/fixtures/imports/security_check_namespace.subm b/crates/submilli-engine/tests/fixtures/imports/security_check_namespace.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/security_check_namespace.subm rename to crates/submilli-engine/tests/fixtures/imports/security_check_namespace.subm diff --git a/crates/interpreter/tests/fixtures/imports/session_aliased.ts b/crates/submilli-engine/tests/fixtures/imports/session_aliased.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_aliased.ts rename to crates/submilli-engine/tests/fixtures/imports/session_aliased.ts diff --git a/crates/interpreter/tests/fixtures/imports/session_named.ts b/crates/submilli-engine/tests/fixtures/imports/session_named.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_named.ts rename to crates/submilli-engine/tests/fixtures/imports/session_named.ts diff --git a/crates/interpreter/tests/fixtures/imports/session_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/session_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/session_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/session_package_caller/app/main.ts b/crates/submilli-engine/tests/fixtures/imports/session_package_caller/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_package_caller/app/main.ts rename to crates/submilli-engine/tests/fixtures/imports/session_package_caller/app/main.ts diff --git a/crates/interpreter/tests/fixtures/imports/session_package_caller/packages.manifest b/crates/submilli-engine/tests/fixtures/imports/session_package_caller/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_package_caller/packages.manifest rename to crates/submilli-engine/tests/fixtures/imports/session_package_caller/packages.manifest diff --git a/crates/interpreter/tests/fixtures/imports/session_package_caller/store/lib.ts b/crates/submilli-engine/tests/fixtures/imports/session_package_caller/store/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_package_caller/store/lib.ts rename to crates/submilli-engine/tests/fixtures/imports/session_package_caller/store/lib.ts diff --git a/crates/interpreter/tests/fixtures/imports/session_wildcard_namespace.ts b/crates/submilli-engine/tests/fixtures/imports/session_wildcard_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/imports/session_wildcard_namespace.ts rename to crates/submilli-engine/tests/fixtures/imports/session_wildcard_namespace.ts diff --git a/crates/interpreter/tests/fixtures/imports/uuid_aliased.subm b/crates/submilli-engine/tests/fixtures/imports/uuid_aliased.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/uuid_aliased.subm rename to crates/submilli-engine/tests/fixtures/imports/uuid_aliased.subm diff --git a/crates/interpreter/tests/fixtures/imports/uuid_named.subm b/crates/submilli-engine/tests/fixtures/imports/uuid_named.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/uuid_named.subm rename to crates/submilli-engine/tests/fixtures/imports/uuid_named.subm diff --git a/crates/interpreter/tests/fixtures/imports/uuid_namespace.subm b/crates/submilli-engine/tests/fixtures/imports/uuid_namespace.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/uuid_namespace.subm rename to crates/submilli-engine/tests/fixtures/imports/uuid_namespace.subm diff --git a/crates/interpreter/tests/fixtures/imports/uuid_v7.subm b/crates/submilli-engine/tests/fixtures/imports/uuid_v7.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/uuid_v7.subm rename to crates/submilli-engine/tests/fixtures/imports/uuid_v7.subm diff --git a/crates/interpreter/tests/fixtures/imports/uuid_wildcard_namespace.subm b/crates/submilli-engine/tests/fixtures/imports/uuid_wildcard_namespace.subm similarity index 100% rename from crates/interpreter/tests/fixtures/imports/uuid_wildcard_namespace.subm rename to crates/submilli-engine/tests/fixtures/imports/uuid_wildcard_namespace.subm diff --git a/crates/interpreter/tests/fixtures/inferred_closure_return_widening.ts b/crates/submilli-engine/tests/fixtures/inferred_closure_return_widening.ts similarity index 100% rename from crates/interpreter/tests/fixtures/inferred_closure_return_widening.ts rename to crates/submilli-engine/tests/fixtures/inferred_closure_return_widening.ts diff --git a/crates/interpreter/tests/fixtures/inferred_literal_extra_fields.ts b/crates/submilli-engine/tests/fixtures/inferred_literal_extra_fields.ts similarity index 100% rename from crates/interpreter/tests/fixtures/inferred_literal_extra_fields.ts rename to crates/submilli-engine/tests/fixtures/inferred_literal_extra_fields.ts diff --git a/crates/interpreter/tests/fixtures/infinity_nan_parameter_defaults.ts b/crates/submilli-engine/tests/fixtures/infinity_nan_parameter_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/infinity_nan_parameter_defaults.ts rename to crates/submilli-engine/tests/fixtures/infinity_nan_parameter_defaults.ts diff --git a/crates/interpreter/tests/fixtures/inherited_method_lift_substitutes.ts b/crates/submilli-engine/tests/fixtures/inherited_method_lift_substitutes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/inherited_method_lift_substitutes.ts rename to crates/submilli-engine/tests/fixtures/inherited_method_lift_substitutes.ts diff --git a/crates/interpreter/tests/fixtures/initializer_narrowing.ts b/crates/submilli-engine/tests/fixtures/initializer_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/initializer_narrowing.ts rename to crates/submilli-engine/tests/fixtures/initializer_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/initializer_union_shapes.ts b/crates/submilli-engine/tests/fixtures/initializer_union_shapes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/initializer_union_shapes.ts rename to crates/submilli-engine/tests/fixtures/initializer_union_shapes.ts diff --git a/crates/interpreter/tests/fixtures/interface_to_string.ts b/crates/submilli-engine/tests/fixtures/interface_to_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interface_to_string.ts rename to crates/submilli-engine/tests/fixtures/interface_to_string.ts diff --git a/crates/interpreter/tests/fixtures/interface_value_capture.subm b/crates/submilli-engine/tests/fixtures/interface_value_capture.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interface_value_capture.subm rename to crates/submilli-engine/tests/fixtures/interface_value_capture.subm diff --git a/crates/interpreter/tests/fixtures/interface_value_into_nullable_object_return.ts b/crates/submilli-engine/tests/fixtures/interface_value_into_nullable_object_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interface_value_into_nullable_object_return.ts rename to crates/submilli-engine/tests/fixtures/interface_value_into_nullable_object_return.ts diff --git a/crates/interpreter/tests/fixtures/interface_value_into_object_slot.ts b/crates/submilli-engine/tests/fixtures/interface_value_into_object_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interface_value_into_object_slot.ts rename to crates/submilli-engine/tests/fixtures/interface_value_into_object_slot.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/expansive_recursive_assign.ts b/crates/submilli-engine/tests/fixtures/interfaces/expansive_recursive_assign.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expansive_recursive_assign.ts rename to crates/submilli-engine/tests/fixtures/interfaces/expansive_recursive_assign.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_bad_member_separator.ts b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_bad_member_separator.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_bad_member_separator.ts rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_bad_member_separator.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm b/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm rename to crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/interface_property_no_literal.ts b/crates/submilli-engine/tests/fixtures/interfaces/interface_property_no_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/interface_property_no_literal.ts rename to crates/submilli-engine/tests/fixtures/interfaces/interface_property_no_literal.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/single_line_members.ts b/crates/submilli-engine/tests/fixtures/interfaces/single_line_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/single_line_members.ts rename to crates/submilli-engine/tests/fixtures/interfaces/single_line_members.ts diff --git a/crates/interpreter/tests/fixtures/interfaces/structural_object_interface_assign.subm b/crates/submilli-engine/tests/fixtures/interfaces/structural_object_interface_assign.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/structural_object_interface_assign.subm rename to crates/submilli-engine/tests/fixtures/interfaces/structural_object_interface_assign.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/user_interface_decl_typechecks.subm b/crates/submilli-engine/tests/fixtures/interfaces/user_interface_decl_typechecks.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/user_interface_decl_typechecks.subm rename to crates/submilli-engine/tests/fixtures/interfaces/user_interface_decl_typechecks.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/user_interface_factory.subm b/crates/submilli-engine/tests/fixtures/interfaces/user_interface_factory.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/user_interface_factory.subm rename to crates/submilli-engine/tests/fixtures/interfaces/user_interface_factory.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/user_interface_nested_field.subm b/crates/submilli-engine/tests/fixtures/interfaces/user_interface_nested_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/user_interface_nested_field.subm rename to crates/submilli-engine/tests/fixtures/interfaces/user_interface_nested_field.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/user_interface_property_read.subm b/crates/submilli-engine/tests/fixtures/interfaces/user_interface_property_read.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/user_interface_property_read.subm rename to crates/submilli-engine/tests/fixtures/interfaces/user_interface_property_read.subm diff --git a/crates/interpreter/tests/fixtures/interfaces/user_interface_value_method_call.subm b/crates/submilli-engine/tests/fixtures/interfaces/user_interface_value_method_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/interfaces/user_interface_value_method_call.subm rename to crates/submilli-engine/tests/fixtures/interfaces/user_interface_value_method_call.subm diff --git a/crates/interpreter/tests/fixtures/is_array.subm b/crates/submilli-engine/tests/fixtures/is_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/is_array.subm rename to crates/submilli-engine/tests/fixtures/is_array.subm diff --git a/crates/interpreter/tests/fixtures/is_primitive.subm b/crates/submilli-engine/tests/fixtures/is_primitive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/is_primitive.subm rename to crates/submilli-engine/tests/fixtures/is_primitive.subm diff --git a/crates/interpreter/tests/fixtures/issue_1147_array_capacity.ts b/crates/submilli-engine/tests/fixtures/issue_1147_array_capacity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_1147_array_capacity.ts rename to crates/submilli-engine/tests/fixtures/issue_1147_array_capacity.ts diff --git a/crates/interpreter/tests/fixtures/issue_1147_push_compatibility.ts b/crates/submilli-engine/tests/fixtures/issue_1147_push_compatibility.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_1147_push_compatibility.ts rename to crates/submilli-engine/tests/fixtures/issue_1147_push_compatibility.ts diff --git a/crates/interpreter/tests/fixtures/issue_821/functions.ts b/crates/submilli-engine/tests/fixtures/issue_821/functions.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_821/functions.ts rename to crates/submilli-engine/tests/fixtures/issue_821/functions.ts diff --git a/crates/interpreter/tests/fixtures/issue_821/optional_functions.ts b/crates/submilli-engine/tests/fixtures/issue_821/optional_functions.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_821/optional_functions.ts rename to crates/submilli-engine/tests/fixtures/issue_821/optional_functions.ts diff --git a/crates/interpreter/tests/fixtures/issue_821/top_level_function.ts b/crates/submilli-engine/tests/fixtures/issue_821/top_level_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_821/top_level_function.ts rename to crates/submilli-engine/tests/fixtures/issue_821/top_level_function.ts diff --git a/crates/interpreter/tests/fixtures/issue_831/cycles.ts b/crates/submilli-engine/tests/fixtures/issue_831/cycles.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_831/cycles.ts rename to crates/submilli-engine/tests/fixtures/issue_831/cycles.ts diff --git a/crates/interpreter/tests/fixtures/issue_831/mixed_cycles.ts b/crates/submilli-engine/tests/fixtures/issue_831/mixed_cycles.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_831/mixed_cycles.ts rename to crates/submilli-engine/tests/fixtures/issue_831/mixed_cycles.ts diff --git a/crates/interpreter/tests/fixtures/issue_836/number_format.ts b/crates/submilli-engine/tests/fixtures/issue_836/number_format.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_836/number_format.ts rename to crates/submilli-engine/tests/fixtures/issue_836/number_format.ts diff --git a/crates/interpreter/tests/fixtures/issue_844/null_algebra.ts b/crates/submilli-engine/tests/fixtures/issue_844/null_algebra.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_844/null_algebra.ts rename to crates/submilli-engine/tests/fixtures/issue_844/null_algebra.ts diff --git a/crates/interpreter/tests/fixtures/issue_844/null_keys.ts b/crates/submilli-engine/tests/fixtures/issue_844/null_keys.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_844/null_keys.ts rename to crates/submilli-engine/tests/fixtures/issue_844/null_keys.ts diff --git a/crates/interpreter/tests/fixtures/issue_872/array_discriminant.ts b/crates/submilli-engine/tests/fixtures/issue_872/array_discriminant.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_872/array_discriminant.ts rename to crates/submilli-engine/tests/fixtures/issue_872/array_discriminant.ts diff --git a/crates/interpreter/tests/fixtures/issue_872/array_guard_boundaries.ts b/crates/submilli-engine/tests/fixtures/issue_872/array_guard_boundaries.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_872/array_guard_boundaries.ts rename to crates/submilli-engine/tests/fixtures/issue_872/array_guard_boundaries.ts diff --git a/crates/interpreter/tests/fixtures/issue_899/expect_error_distinct_enums.ts b/crates/submilli-engine/tests/fixtures/issue_899/expect_error_distinct_enums.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_899/expect_error_distinct_enums.ts rename to crates/submilli-engine/tests/fixtures/issue_899/expect_error_distinct_enums.ts diff --git a/crates/interpreter/tests/fixtures/issue_899/primitive_enum.ts b/crates/submilli-engine/tests/fixtures/issue_899/primitive_enum.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_899/primitive_enum.ts rename to crates/submilli-engine/tests/fixtures/issue_899/primitive_enum.ts diff --git a/crates/interpreter/tests/fixtures/issue_965/global_call_reassignment.ts b/crates/submilli-engine/tests/fixtures/issue_965/global_call_reassignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_965/global_call_reassignment.ts rename to crates/submilli-engine/tests/fixtures/issue_965/global_call_reassignment.ts diff --git a/crates/interpreter/tests/fixtures/issue_966/insert_optional.ts b/crates/submilli-engine/tests/fixtures/issue_966/insert_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_966/insert_optional.ts rename to crates/submilli-engine/tests/fixtures/issue_966/insert_optional.ts diff --git a/crates/interpreter/tests/fixtures/issue_966/inserted_fields_json.ts b/crates/submilli-engine/tests/fixtures/issue_966/inserted_fields_json.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_966/inserted_fields_json.ts rename to crates/submilli-engine/tests/fixtures/issue_966/inserted_fields_json.ts diff --git a/crates/interpreter/tests/fixtures/issue_966/insertion_during_write.ts b/crates/submilli-engine/tests/fixtures/issue_966/insertion_during_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_966/insertion_during_write.ts rename to crates/submilli-engine/tests/fixtures/issue_966/insertion_during_write.ts diff --git a/crates/interpreter/tests/fixtures/issue_966/insertion_preserves_guards.ts b/crates/submilli-engine/tests/fixtures/issue_966/insertion_preserves_guards.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_966/insertion_preserves_guards.ts rename to crates/submilli-engine/tests/fixtures/issue_966/insertion_preserves_guards.ts diff --git a/crates/interpreter/tests/fixtures/issue_968/conditional_loop_writes.ts b/crates/submilli-engine/tests/fixtures/issue_968/conditional_loop_writes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_968/conditional_loop_writes.ts rename to crates/submilli-engine/tests/fixtures/issue_968/conditional_loop_writes.ts diff --git a/crates/interpreter/tests/fixtures/issue_968/nested_loop_writes.ts b/crates/submilli-engine/tests/fixtures/issue_968/nested_loop_writes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_968/nested_loop_writes.ts rename to crates/submilli-engine/tests/fixtures/issue_968/nested_loop_writes.ts diff --git a/crates/interpreter/tests/fixtures/issue_970/accessor_enumeration.ts b/crates/submilli-engine/tests/fixtures/issue_970/accessor_enumeration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_970/accessor_enumeration.ts rename to crates/submilli-engine/tests/fixtures/issue_970/accessor_enumeration.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/compound_literal_operands.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/compound_literal_operands.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/compound_literal_operands.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/compound_literal_operands.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/conditional_literal_results.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/conditional_literal_results.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/conditional_literal_results.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/conditional_literal_results.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/disjunction_guard.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/disjunction_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/disjunction_guard.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/disjunction_guard.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/enum_literal_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/enum_literal_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/enum_literal_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/enum_literal_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/finally_break_return.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/finally_break_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/finally_break_return.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/finally_break_return.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/finite_alias_depth.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/finite_alias_depth.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/finite_alias_depth.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/finite_alias_depth.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/literal_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/literal_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/literal_equality_aliases.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality_aliases.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/literal_equality_aliases.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality_aliases.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/logical_interpolation.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/logical_interpolation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/logical_interpolation.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/logical_interpolation.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/nullable_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/nullable_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/nullable_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/nullable_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/object_spread.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/object_spread.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/object_spread.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/object_spread_integration.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_integration.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/object_spread_integration.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_integration.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/object_spread_overrides.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_overrides.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/object_spread_overrides.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_overrides.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/object_spread_presence.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_presence.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/object_spread_presence.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_presence.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/polymorphic_covariance.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/polymorphic_covariance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/polymorphic_covariance.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/polymorphic_covariance.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/signed_literal_equality.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/signed_literal_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/signed_literal_equality.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/signed_literal_equality.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/switch_try_termination.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/switch_try_termination.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/switch_try_termination.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/switch_try_termination.ts diff --git a/crates/interpreter/tests/fixtures/issue_regressions/void_callback.ts b/crates/submilli-engine/tests/fixtures/issue_regressions/void_callback.ts similarity index 100% rename from crates/interpreter/tests/fixtures/issue_regressions/void_callback.ts rename to crates/submilli-engine/tests/fixtures/issue_regressions/void_callback.ts diff --git a/crates/interpreter/tests/fixtures/iterators/close_called_on_break.subm b/crates/submilli-engine/tests/fixtures/iterators/close_called_on_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/close_called_on_break.subm rename to crates/submilli-engine/tests/fixtures/iterators/close_called_on_break.subm diff --git a/crates/interpreter/tests/fixtures/iterators/close_called_on_exhaustion.subm b/crates/submilli-engine/tests/fixtures/iterators/close_called_on_exhaustion.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/close_called_on_exhaustion.subm rename to crates/submilli-engine/tests/fixtures/iterators/close_called_on_exhaustion.subm diff --git a/crates/interpreter/tests/fixtures/iterators/close_called_on_throw.subm b/crates/submilli-engine/tests/fixtures/iterators/close_called_on_throw.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/close_called_on_throw.subm rename to crates/submilli-engine/tests/fixtures/iterators/close_called_on_throw.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm b/crates/submilli-engine/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterable_hand_rolled.subm b/crates/submilli-engine/tests/fixtures/iterators/iterable_hand_rolled.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterable_hand_rolled.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterable_hand_rolled.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterator_break.subm b/crates/submilli-engine/tests/fixtures/iterators/iterator_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterator_break.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterator_break.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterator_continue.subm b/crates/submilli-engine/tests/fixtures/iterators/iterator_continue.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterator_continue.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterator_continue.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterator_hand_rolled.subm b/crates/submilli-engine/tests/fixtures/iterators/iterator_hand_rolled.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterator_hand_rolled.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterator_hand_rolled.subm diff --git a/crates/interpreter/tests/fixtures/iterators/iterator_nullable_t.subm b/crates/submilli-engine/tests/fixtures/iterators/iterator_nullable_t.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/iterator_nullable_t.subm rename to crates/submilli-engine/tests/fixtures/iterators/iterator_nullable_t.subm diff --git a/crates/interpreter/tests/fixtures/iterators/no_close_no_crash.subm b/crates/submilli-engine/tests/fixtures/iterators/no_close_no_crash.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/no_close_no_crash.subm rename to crates/submilli-engine/tests/fixtures/iterators/no_close_no_crash.subm diff --git a/crates/interpreter/tests/fixtures/iterators/user_interface_iterable.subm b/crates/submilli-engine/tests/fixtures/iterators/user_interface_iterable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/iterators/user_interface_iterable.subm rename to crates/submilli-engine/tests/fixtures/iterators/user_interface_iterable.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_bare_json.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_bare_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_bare_json.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_bare_json.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_let_json_parse.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_let_json_parse.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_let_json_parse.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_let_json_parse.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_parse_function_target.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_parse_function_target.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_parse_function_target.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_parse_function_target.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_parse_too_many_type_args.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_parse_too_many_type_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_parse_too_many_type_args.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_parse_too_many_type_args.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_parse_type_args_and_as.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_parse_type_args_and_as.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_parse_type_args_and_as.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_parse_type_args_and_as.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_parse_uint8array_target.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_parse_uint8array_target.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_parse_uint8array_target.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_parse_uint8array_target.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_partial_json.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_partial_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_partial_json.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_partial_json.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_stringify_replacer.ts b/crates/submilli-engine/tests/fixtures/json/expect_error_stringify_replacer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_stringify_replacer.ts rename to crates/submilli-engine/tests/fixtures/json/expect_error_stringify_replacer.ts diff --git a/crates/interpreter/tests/fixtures/json/expect_error_stringify_type_args.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_stringify_type_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_stringify_type_args.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_stringify_type_args.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_signature.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_signature.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_signature.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_signature.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_type.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_type.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_type.subm diff --git a/crates/interpreter/tests/fixtures/json/expect_error_unknown_json_member.subm b/crates/submilli-engine/tests/fixtures/json/expect_error_unknown_json_member.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/expect_error_unknown_json_member.subm rename to crates/submilli-engine/tests/fixtures/json/expect_error_unknown_json_member.subm diff --git a/crates/interpreter/tests/fixtures/json/interface_optional_omitted.ts b/crates/submilli-engine/tests/fixtures/json/interface_optional_omitted.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/interface_optional_omitted.ts rename to crates/submilli-engine/tests/fixtures/json/interface_optional_omitted.ts diff --git a/crates/interpreter/tests/fixtures/json/main_array_return.subm b/crates/submilli-engine/tests/fixtures/json/main_array_return.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/main_array_return.subm rename to crates/submilli-engine/tests/fixtures/json/main_array_return.subm diff --git a/crates/interpreter/tests/fixtures/json/main_object_return.subm b/crates/submilli-engine/tests/fixtures/json/main_object_return.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/main_object_return.subm rename to crates/submilli-engine/tests/fixtures/json/main_object_return.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_literal.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_literal.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_literal.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_numbers.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_numbers.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_numbers.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_numbers.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_objects.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_objects.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_objects.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_objects.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_strings.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_strings.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_strings.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_strings.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_tuples.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_tuples.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_tuples.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_tuples.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_array_of_union.subm b/crates/submilli-engine/tests/fixtures/json/parse_array_of_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_array_of_union.subm rename to crates/submilli-engine/tests/fixtures/json/parse_array_of_union.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_as_cast.subm b/crates/submilli-engine/tests/fixtures/json/parse_as_cast.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_as_cast.subm rename to crates/submilli-engine/tests/fixtures/json/parse_as_cast.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_bool.subm b/crates/submilli-engine/tests/fixtures/json/parse_bool.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_bool.subm rename to crates/submilli-engine/tests/fixtures/json/parse_bool.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_diagnostic_preview_path.subm b/crates/submilli-engine/tests/fixtures/json/parse_diagnostic_preview_path.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_diagnostic_preview_path.subm rename to crates/submilli-engine/tests/fixtures/json/parse_diagnostic_preview_path.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_explicit_generic.subm b/crates/submilli-engine/tests/fixtures/json/parse_explicit_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_explicit_generic.subm rename to crates/submilli-engine/tests/fixtures/json/parse_explicit_generic.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_field_union.subm b/crates/submilli-engine/tests/fixtures/json/parse_field_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_field_union.subm rename to crates/submilli-engine/tests/fixtures/json/parse_field_union.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_inferred_interface.ts b/crates/submilli-engine/tests/fixtures/json/parse_inferred_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_inferred_interface.ts rename to crates/submilli-engine/tests/fixtures/json/parse_inferred_interface.ts diff --git a/crates/interpreter/tests/fixtures/json/parse_into_generic_interface.subm b/crates/submilli-engine/tests/fixtures/json/parse_into_generic_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_into_generic_interface.subm rename to crates/submilli-engine/tests/fixtures/json/parse_into_generic_interface.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_into_interface.subm b/crates/submilli-engine/tests/fixtures/json/parse_into_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_into_interface.subm rename to crates/submilli-engine/tests/fixtures/json/parse_into_interface.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_into_interface_nested.subm b/crates/submilli-engine/tests/fixtures/json/parse_into_interface_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_into_interface_nested.subm rename to crates/submilli-engine/tests/fixtures/json/parse_into_interface_nested.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_into_recursive_interface.subm b/crates/submilli-engine/tests/fixtures/json/parse_into_recursive_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_into_recursive_interface.subm rename to crates/submilli-engine/tests/fixtures/json/parse_into_recursive_interface.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_invalid_throws.subm b/crates/submilli-engine/tests/fixtures/json/parse_invalid_throws.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_invalid_throws.subm rename to crates/submilli-engine/tests/fixtures/json/parse_invalid_throws.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_mismatch_throws.subm b/crates/submilli-engine/tests/fixtures/json/parse_mismatch_throws.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_mismatch_throws.subm rename to crates/submilli-engine/tests/fixtures/json/parse_mismatch_throws.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_nested.subm b/crates/submilli-engine/tests/fixtures/json/parse_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_nested.subm rename to crates/submilli-engine/tests/fixtures/json/parse_nested.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_null.subm b/crates/submilli-engine/tests/fixtures/json/parse_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_null.subm rename to crates/submilli-engine/tests/fixtures/json/parse_null.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_number.subm b/crates/submilli-engine/tests/fixtures/json/parse_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_number.subm rename to crates/submilli-engine/tests/fixtures/json/parse_number.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_number_literal_target.subm b/crates/submilli-engine/tests/fixtures/json/parse_number_literal_target.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_number_literal_target.subm rename to crates/submilli-engine/tests/fixtures/json/parse_number_literal_target.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_equals_hash.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_equals_hash.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_equals_hash.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_equals_hash.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_lenient.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_lenient.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_lenient.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_lenient.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_literal_field.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_literal_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_literal_field.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_literal_field.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_nullable_field.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_nullable_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_nullable_field.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_nullable_field.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_optional_field.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_optional_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_optional_field.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_optional_field.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_round_trip.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_round_trip.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_object_simple.subm b/crates/submilli-engine/tests/fixtures/json/parse_object_simple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_object_simple.subm rename to crates/submilli-engine/tests/fixtures/json/parse_object_simple.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_recursive_discriminated.subm b/crates/submilli-engine/tests/fixtures/json/parse_recursive_discriminated.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_recursive_discriminated.subm rename to crates/submilli-engine/tests/fixtures/json/parse_recursive_discriminated.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_recursive_linked_list.subm b/crates/submilli-engine/tests/fixtures/json/parse_recursive_linked_list.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_recursive_linked_list.subm rename to crates/submilli-engine/tests/fixtures/json/parse_recursive_linked_list.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_recursive_object.subm b/crates/submilli-engine/tests/fixtures/json/parse_recursive_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_recursive_object.subm rename to crates/submilli-engine/tests/fixtures/json/parse_recursive_object.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_recursive_union.subm b/crates/submilli-engine/tests/fixtures/json/parse_recursive_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_recursive_union.subm rename to crates/submilli-engine/tests/fixtures/json/parse_recursive_union.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_string.subm b/crates/submilli-engine/tests/fixtures/json/parse_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_string.subm rename to crates/submilli-engine/tests/fixtures/json/parse_string.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_string_literal_target.subm b/crates/submilli-engine/tests/fixtures/json/parse_string_literal_target.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_string_literal_target.subm rename to crates/submilli-engine/tests/fixtures/json/parse_string_literal_target.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_t_or_null.subm b/crates/submilli-engine/tests/fixtures/json/parse_t_or_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_t_or_null.subm rename to crates/submilli-engine/tests/fixtures/json/parse_t_or_null.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_tuple_basic.subm b/crates/submilli-engine/tests/fixtures/json/parse_tuple_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_tuple_basic.subm rename to crates/submilli-engine/tests/fixtures/json/parse_tuple_basic.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_tuple_in_object.subm b/crates/submilli-engine/tests/fixtures/json/parse_tuple_in_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_tuple_in_object.subm rename to crates/submilli-engine/tests/fixtures/json/parse_tuple_in_object.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_tuple_literal_position.subm b/crates/submilli-engine/tests/fixtures/json/parse_tuple_literal_position.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_tuple_literal_position.subm rename to crates/submilli-engine/tests/fixtures/json/parse_tuple_literal_position.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_tuple_nested.subm b/crates/submilli-engine/tests/fixtures/json/parse_tuple_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_tuple_nested.subm rename to crates/submilli-engine/tests/fixtures/json/parse_tuple_nested.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_tuple_round_trip.subm b/crates/submilli-engine/tests/fixtures/json/parse_tuple_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_tuple_round_trip.subm rename to crates/submilli-engine/tests/fixtures/json/parse_tuple_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_literal_set.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_literal_set.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_literal_set.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_literal_set.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_mixed_tags.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_mixed_tags.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_mixed_tags.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_mixed_tags.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_primitive.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_primitive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_primitive.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_primitive.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_shared_tag.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_shared_tag.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_shared_tag.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_shared_tag.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_status_code.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_status_code.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_status_code.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_status_code.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_tagged.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_tagged.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_tagged.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_tagged.subm diff --git a/crates/interpreter/tests/fixtures/json/parse_union_untagged.subm b/crates/submilli-engine/tests/fixtures/json/parse_union_untagged.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/parse_union_untagged.subm rename to crates/submilli-engine/tests/fixtures/json/parse_union_untagged.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_array.subm b/crates/submilli-engine/tests/fixtures/json/stringify_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_array.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_array.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_as_string.subm b/crates/submilli-engine/tests/fixtures/json/stringify_as_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_as_string.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_as_string.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_bool.subm b/crates/submilli-engine/tests/fixtures/json/stringify_bool.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_bool.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_bool.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_interface_array_round_trip.subm b/crates/submilli-engine/tests/fixtures/json/stringify_interface_array_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_interface_array_round_trip.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_interface_array_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_interface_optional_field_assigned.ts b/crates/submilli-engine/tests/fixtures/json/stringify_interface_optional_field_assigned.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_interface_optional_field_assigned.ts rename to crates/submilli-engine/tests/fixtures/json/stringify_interface_optional_field_assigned.ts diff --git a/crates/interpreter/tests/fixtures/json/stringify_negative_zero.subm b/crates/submilli-engine/tests/fixtures/json/stringify_negative_zero.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_negative_zero.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_negative_zero.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_null.subm b/crates/submilli-engine/tests/fixtures/json/stringify_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_null.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_null.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_null_valued_nullable_field.subm b/crates/submilli-engine/tests/fixtures/json/stringify_null_valued_nullable_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_null_valued_nullable_field.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_null_valued_nullable_field.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_nullable_number.subm b/crates/submilli-engine/tests/fixtures/json/stringify_nullable_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_nullable_number.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_nullable_number.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_nullable_object.subm b/crates/submilli-engine/tests/fixtures/json/stringify_nullable_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_nullable_object.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_nullable_object.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_nullable_string.subm b/crates/submilli-engine/tests/fixtures/json/stringify_nullable_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_nullable_string.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_nullable_string.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_number.subm b/crates/submilli-engine/tests/fixtures/json/stringify_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_number.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_number.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_object.subm b/crates/submilli-engine/tests/fixtures/json/stringify_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_object.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_object.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_object_optional_field.subm b/crates/submilli-engine/tests/fixtures/json/stringify_object_optional_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_object_optional_field.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_object_optional_field.subm diff --git a/crates/interpreter/tests/fixtures/json/stringify_pretty_eval_order.ts b/crates/submilli-engine/tests/fixtures/json/stringify_pretty_eval_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_pretty_eval_order.ts rename to crates/submilli-engine/tests/fixtures/json/stringify_pretty_eval_order.ts diff --git a/crates/interpreter/tests/fixtures/json/stringify_pretty_space_number.ts b/crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_number.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_pretty_space_number.ts rename to crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_number.ts diff --git a/crates/interpreter/tests/fixtures/json/stringify_pretty_space_string.ts b/crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_pretty_space_string.ts rename to crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_string.ts diff --git a/crates/interpreter/tests/fixtures/json/stringify_string.subm b/crates/submilli-engine/tests/fixtures/json/stringify_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/stringify_string.subm rename to crates/submilli-engine/tests/fixtures/json/stringify_string.subm diff --git a/crates/interpreter/tests/fixtures/json/to_json_direct.subm b/crates/submilli-engine/tests/fixtures/json/to_json_direct.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/to_json_direct.subm rename to crates/submilli-engine/tests/fixtures/json/to_json_direct.subm diff --git a/crates/interpreter/tests/fixtures/json/to_json_field_override.subm b/crates/submilli-engine/tests/fixtures/json/to_json_field_override.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/to_json_field_override.subm rename to crates/submilli-engine/tests/fixtures/json/to_json_field_override.subm diff --git a/crates/interpreter/tests/fixtures/json/to_json_field_override_with_capture.subm b/crates/submilli-engine/tests/fixtures/json/to_json_field_override_with_capture.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/to_json_field_override_with_capture.subm rename to crates/submilli-engine/tests/fixtures/json/to_json_field_override_with_capture.subm diff --git a/crates/interpreter/tests/fixtures/json/to_json_via_generic.subm b/crates/submilli-engine/tests/fixtures/json/to_json_via_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/json/to_json_via_generic.subm rename to crates/submilli-engine/tests/fixtures/json/to_json_via_generic.subm diff --git a/crates/interpreter/tests/fixtures/json_parse_lone_surrogate.ts b/crates/submilli-engine/tests/fixtures/json_parse_lone_surrogate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_parse_lone_surrogate.ts rename to crates/submilli-engine/tests/fixtures/json_parse_lone_surrogate.ts diff --git a/crates/interpreter/tests/fixtures/json_stringify_collection.ts b/crates/submilli-engine/tests/fixtures/json_stringify_collection.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_stringify_collection.ts rename to crates/submilli-engine/tests/fixtures/json_stringify_collection.ts diff --git a/crates/interpreter/tests/fixtures/json_stringify_erased_null.ts b/crates/submilli-engine/tests/fixtures/json_stringify_erased_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_stringify_erased_null.ts rename to crates/submilli-engine/tests/fixtures/json_stringify_erased_null.ts diff --git a/crates/interpreter/tests/fixtures/json_stringify_reassigned_field.ts b/crates/submilli-engine/tests/fixtures/json_stringify_reassigned_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_stringify_reassigned_field.ts rename to crates/submilli-engine/tests/fixtures/json_stringify_reassigned_field.ts diff --git a/crates/interpreter/tests/fixtures/json_stringify_width_subtype.ts b/crates/submilli-engine/tests/fixtures/json_stringify_width_subtype.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_stringify_width_subtype.ts rename to crates/submilli-engine/tests/fixtures/json_stringify_width_subtype.ts diff --git a/crates/interpreter/tests/fixtures/json_utf16_lossless.ts b/crates/submilli-engine/tests/fixtures/json_utf16_lossless.ts similarity index 100% rename from crates/interpreter/tests/fixtures/json_utf16_lossless.ts rename to crates/submilli-engine/tests/fixtures/json_utf16_lossless.ts diff --git a/crates/interpreter/tests/fixtures/later_module_variable_shadows_namespace.ts b/crates/submilli-engine/tests/fixtures/later_module_variable_shadows_namespace.ts similarity index 100% rename from crates/interpreter/tests/fixtures/later_module_variable_shadows_namespace.ts rename to crates/submilli-engine/tests/fixtures/later_module_variable_shadows_namespace.ts diff --git a/crates/interpreter/tests/fixtures/let_keeps_regular_literal_types.ts b/crates/submilli-engine/tests/fixtures/let_keeps_regular_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/let_keeps_regular_literal_types.ts rename to crates/submilli-engine/tests/fixtures/let_keeps_regular_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/linear_regex_output.ts b/crates/submilli-engine/tests/fixtures/linear_regex_output.ts similarity index 100% rename from crates/interpreter/tests/fixtures/linear_regex_output.ts rename to crates/submilli-engine/tests/fixtures/linear_regex_output.ts diff --git a/crates/interpreter/tests/fixtures/linear_string_transforms.ts b/crates/submilli-engine/tests/fixtures/linear_string_transforms.ts similarity index 100% rename from crates/interpreter/tests/fixtures/linear_string_transforms.ts rename to crates/submilli-engine/tests/fixtures/linear_string_transforms.ts diff --git a/crates/interpreter/tests/fixtures/literal_keeping_operators.ts b/crates/submilli-engine/tests/fixtures/literal_keeping_operators.ts similarity index 100% rename from crates/interpreter/tests/fixtures/literal_keeping_operators.ts rename to crates/submilli-engine/tests/fixtures/literal_keeping_operators.ts diff --git a/crates/interpreter/tests/fixtures/literal_own_type_keeps_binding_writable.ts b/crates/submilli-engine/tests/fixtures/literal_own_type_keeps_binding_writable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/literal_own_type_keeps_binding_writable.ts rename to crates/submilli-engine/tests/fixtures/literal_own_type_keeps_binding_writable.ts diff --git a/crates/interpreter/tests/fixtures/literal_own_type_under_annotation.ts b/crates/submilli-engine/tests/fixtures/literal_own_type_under_annotation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/literal_own_type_under_annotation.ts rename to crates/submilli-engine/tests/fixtures/literal_own_type_under_annotation.ts diff --git a/crates/interpreter/tests/fixtures/literal_type_capture.subm b/crates/submilli-engine/tests/fixtures/literal_type_capture.subm similarity index 100% rename from crates/interpreter/tests/fixtures/literal_type_capture.subm rename to crates/submilli-engine/tests/fixtures/literal_type_capture.subm diff --git a/crates/interpreter/tests/fixtures/literal_type_number.subm b/crates/submilli-engine/tests/fixtures/literal_type_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/literal_type_number.subm rename to crates/submilli-engine/tests/fixtures/literal_type_number.subm diff --git a/crates/interpreter/tests/fixtures/literal_type_string.subm b/crates/submilli-engine/tests/fixtures/literal_type_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/literal_type_string.subm rename to crates/submilli-engine/tests/fixtures/literal_type_string.subm diff --git a/crates/interpreter/tests/fixtures/literal_type_union.subm b/crates/submilli-engine/tests/fixtures/literal_type_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/literal_type_union.subm rename to crates/submilli-engine/tests/fixtures/literal_type_union.subm diff --git a/crates/interpreter/tests/fixtures/literal_union_interface_field.ts b/crates/submilli-engine/tests/fixtures/literal_union_interface_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/literal_union_interface_field.ts rename to crates/submilli-engine/tests/fixtures/literal_union_interface_field.ts diff --git a/crates/interpreter/tests/fixtures/llm_basic.ts b/crates/submilli-engine/tests/fixtures/llm_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_basic.ts rename to crates/submilli-engine/tests/fixtures/llm_basic.ts diff --git a/crates/interpreter/tests/fixtures/llm_batch_ordering.ts b/crates/submilli-engine/tests/fixtures/llm_batch_ordering.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_batch_ordering.ts rename to crates/submilli-engine/tests/fixtures/llm_batch_ordering.ts diff --git a/crates/interpreter/tests/fixtures/llm_batch_partial_failure.ts b/crates/submilli-engine/tests/fixtures/llm_batch_partial_failure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_batch_partial_failure.ts rename to crates/submilli-engine/tests/fixtures/llm_batch_partial_failure.ts diff --git a/crates/interpreter/tests/fixtures/llm_budget_aggregate.ts b/crates/submilli-engine/tests/fixtures/llm_budget_aggregate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_budget_aggregate.ts rename to crates/submilli-engine/tests/fixtures/llm_budget_aggregate.ts diff --git a/crates/interpreter/tests/fixtures/llm_budget_per_execution.ts b/crates/submilli-engine/tests/fixtures/llm_budget_per_execution.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_budget_per_execution.ts rename to crates/submilli-engine/tests/fixtures/llm_budget_per_execution.ts diff --git a/crates/interpreter/tests/fixtures/llm_budget_release_after_trap.ts b/crates/submilli-engine/tests/fixtures/llm_budget_release_after_trap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_budget_release_after_trap.ts rename to crates/submilli-engine/tests/fixtures/llm_budget_release_after_trap.ts diff --git a/crates/interpreter/tests/fixtures/llm_call_erased.ts b/crates/submilli-engine/tests/fixtures/llm_call_erased.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_call_erased.ts rename to crates/submilli-engine/tests/fixtures/llm_call_erased.ts diff --git a/crates/interpreter/tests/fixtures/llm_call_unknown.ts b/crates/submilli-engine/tests/fixtures/llm_call_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_call_unknown.ts rename to crates/submilli-engine/tests/fixtures/llm_call_unknown.ts diff --git a/crates/interpreter/tests/fixtures/llm_denied.ts b/crates/submilli-engine/tests/fixtures/llm_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_denied.ts rename to crates/submilli-engine/tests/fixtures/llm_denied.ts diff --git a/crates/interpreter/tests/fixtures/llm_error_taxonomy.ts b/crates/submilli-engine/tests/fixtures/llm_error_taxonomy.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_error_taxonomy.ts rename to crates/submilli-engine/tests/fixtures/llm_error_taxonomy.ts diff --git a/crates/interpreter/tests/fixtures/llm_models_all_callable.ts b/crates/submilli-engine/tests/fixtures/llm_models_all_callable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_models_all_callable.ts rename to crates/submilli-engine/tests/fixtures/llm_models_all_callable.ts diff --git a/crates/interpreter/tests/fixtures/llm_models_empty.ts b/crates/submilli-engine/tests/fixtures/llm_models_empty.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_models_empty.ts rename to crates/submilli-engine/tests/fixtures/llm_models_empty.ts diff --git a/crates/interpreter/tests/fixtures/llm_models_filtered.ts b/crates/submilli-engine/tests/fixtures/llm_models_filtered.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_models_filtered.ts rename to crates/submilli-engine/tests/fixtures/llm_models_filtered.ts diff --git a/crates/interpreter/tests/fixtures/llm_models_no_description.ts b/crates/submilli-engine/tests/fixtures/llm_models_no_description.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_models_no_description.ts rename to crates/submilli-engine/tests/fixtures/llm_models_no_description.ts diff --git a/crates/interpreter/tests/fixtures/llm_no_provider.ts b/crates/submilli-engine/tests/fixtures/llm_no_provider.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_no_provider.ts rename to crates/submilli-engine/tests/fixtures/llm_no_provider.ts diff --git a/crates/interpreter/tests/fixtures/llm_prompt_bounds.ts b/crates/submilli-engine/tests/fixtures/llm_prompt_bounds.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_prompt_bounds.ts rename to crates/submilli-engine/tests/fixtures/llm_prompt_bounds.ts diff --git a/crates/interpreter/tests/fixtures/llm_schema_argument_rejected.ts b/crates/submilli-engine/tests/fixtures/llm_schema_argument_rejected.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_schema_argument_rejected.ts rename to crates/submilli-engine/tests/fixtures/llm_schema_argument_rejected.ts diff --git a/crates/interpreter/tests/fixtures/llm_schema_unsupported.ts b/crates/submilli-engine/tests/fixtures/llm_schema_unsupported.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_schema_unsupported.ts rename to crates/submilli-engine/tests/fixtures/llm_schema_unsupported.ts diff --git a/crates/interpreter/tests/fixtures/llm_typed_get.ts b/crates/submilli-engine/tests/fixtures/llm_typed_get.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_typed_get.ts rename to crates/submilli-engine/tests/fixtures/llm_typed_get.ts diff --git a/crates/interpreter/tests/fixtures/llm_typed_mismatch.ts b/crates/submilli-engine/tests/fixtures/llm_typed_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_typed_mismatch.ts rename to crates/submilli-engine/tests/fixtures/llm_typed_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/llm_typed_provider_ignored_schema.ts b/crates/submilli-engine/tests/fixtures/llm_typed_provider_ignored_schema.ts similarity index 100% rename from crates/interpreter/tests/fixtures/llm_typed_provider_ignored_schema.ts rename to crates/submilli-engine/tests/fixtures/llm_typed_provider_ignored_schema.ts diff --git a/crates/interpreter/tests/fixtures/loop_condition_write_narrows.ts b/crates/submilli-engine/tests/fixtures/loop_condition_write_narrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loop_condition_write_narrows.ts rename to crates/submilli-engine/tests/fixtures/loop_condition_write_narrows.ts diff --git a/crates/interpreter/tests/fixtures/loop_empty_body.ts b/crates/submilli-engine/tests/fixtures/loop_empty_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loop_empty_body.ts rename to crates/submilli-engine/tests/fixtures/loop_empty_body.ts diff --git a/crates/interpreter/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts b/crates/submilli-engine/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts rename to crates/submilli-engine/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts diff --git a/crates/interpreter/tests/fixtures/loops/do_while_break.subm b/crates/submilli-engine/tests/fixtures/loops/do_while_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/do_while_break.subm rename to crates/submilli-engine/tests/fixtures/loops/do_while_break.subm diff --git a/crates/interpreter/tests/fixtures/loops/do_while_continue.ts b/crates/submilli-engine/tests/fixtures/loops/do_while_continue.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loops/do_while_continue.ts rename to crates/submilli-engine/tests/fixtures/loops/do_while_continue.ts diff --git a/crates/interpreter/tests/fixtures/loops/do_while_once.subm b/crates/submilli-engine/tests/fixtures/loops/do_while_once.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/do_while_once.subm rename to crates/submilli-engine/tests/fixtures/loops/do_while_once.subm diff --git a/crates/interpreter/tests/fixtures/loops/do_while_truthiness_cond.subm b/crates/submilli-engine/tests/fixtures/loops/do_while_truthiness_cond.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/do_while_truthiness_cond.subm rename to crates/submilli-engine/tests/fixtures/loops/do_while_truthiness_cond.subm diff --git a/crates/interpreter/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm b/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm rename to crates/submilli-engine/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm diff --git a/crates/interpreter/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm b/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm rename to crates/submilli-engine/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm diff --git a/crates/interpreter/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm b/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm rename to crates/submilli-engine/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_basic.subm b/crates/submilli-engine/tests/fixtures/loops/for_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_basic.subm rename to crates/submilli-engine/tests/fixtures/loops/for_basic.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_break.subm b/crates/submilli-engine/tests/fixtures/loops/for_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_break.subm rename to crates/submilli-engine/tests/fixtures/loops/for_break.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_continue.subm b/crates/submilli-engine/tests/fixtures/loops/for_continue.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_continue.subm rename to crates/submilli-engine/tests/fixtures/loops/for_continue.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_empty_slots.subm b/crates/submilli-engine/tests/fixtures/loops/for_empty_slots.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_empty_slots.subm rename to crates/submilli-engine/tests/fixtures/loops/for_empty_slots.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_let_per_iteration_binding.ts b/crates/submilli-engine/tests/fixtures/loops/for_let_per_iteration_binding.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_let_per_iteration_binding.ts rename to crates/submilli-engine/tests/fixtures/loops/for_let_per_iteration_binding.ts diff --git a/crates/interpreter/tests/fixtures/loops/for_nested.subm b/crates/submilli-engine/tests/fixtures/loops/for_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_nested.subm rename to crates/submilli-engine/tests/fixtures/loops/for_nested.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_break.subm b/crates/submilli-engine/tests/fixtures/loops/for_of_break.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_break.subm rename to crates/submilli-engine/tests/fixtures/loops/for_of_break.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_continue.subm b/crates/submilli-engine/tests/fixtures/loops/for_of_continue.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_continue.subm rename to crates/submilli-engine/tests/fixtures/loops/for_of_continue.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_empty.subm b/crates/submilli-engine/tests/fixtures/loops/for_of_empty.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_empty.subm rename to crates/submilli-engine/tests/fixtures/loops/for_of_empty.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_number_array.subm b/crates/submilli-engine/tests/fixtures/loops/for_of_number_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_number_array.subm rename to crates/submilli-engine/tests/fixtures/loops/for_of_number_array.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_string_array.subm b/crates/submilli-engine/tests/fixtures/loops/for_of_string_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_string_array.subm rename to crates/submilli-engine/tests/fixtures/loops/for_of_string_array.subm diff --git a/crates/interpreter/tests/fixtures/loops/for_of_tuple.ts b/crates/submilli-engine/tests/fixtures/loops/for_of_tuple.ts similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_of_tuple.ts rename to crates/submilli-engine/tests/fixtures/loops/for_of_tuple.ts diff --git a/crates/interpreter/tests/fixtures/loops/for_truthiness_cond.subm b/crates/submilli-engine/tests/fixtures/loops/for_truthiness_cond.subm similarity index 100% rename from crates/interpreter/tests/fixtures/loops/for_truthiness_cond.subm rename to crates/submilli-engine/tests/fixtures/loops/for_truthiness_cond.subm diff --git a/crates/interpreter/tests/fixtures/map_for_each.subm b/crates/submilli-engine/tests/fixtures/map_for_each.subm similarity index 100% rename from crates/interpreter/tests/fixtures/map_for_each.subm rename to crates/submilli-engine/tests/fixtures/map_for_each.subm diff --git a/crates/interpreter/tests/fixtures/map_from_differing_tuple_literals.ts b/crates/submilli-engine/tests/fixtures/map_from_differing_tuple_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/map_from_differing_tuple_literals.ts rename to crates/submilli-engine/tests/fixtures/map_from_differing_tuple_literals.ts diff --git a/crates/interpreter/tests/fixtures/map_set_from_iterable.ts b/crates/submilli-engine/tests/fixtures/map_set_from_iterable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/map_set_from_iterable.ts rename to crates/submilli-engine/tests/fixtures/map_set_from_iterable.ts diff --git a/crates/interpreter/tests/fixtures/map_set_identity.ts b/crates/submilli-engine/tests/fixtures/map_set_identity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/map_set_identity.ts rename to crates/submilli-engine/tests/fixtures/map_set_identity.ts diff --git a/crates/interpreter/tests/fixtures/maps/basic_string_keys.subm b/crates/submilli-engine/tests/fixtures/maps/basic_string_keys.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/basic_string_keys.subm rename to crates/submilli-engine/tests/fixtures/maps/basic_string_keys.subm diff --git a/crates/interpreter/tests/fixtures/maps/cached_hashes_and_ledger.ts b/crates/submilli-engine/tests/fixtures/maps/cached_hashes_and_ledger.ts similarity index 100% rename from crates/interpreter/tests/fixtures/maps/cached_hashes_and_ledger.ts rename to crates/submilli-engine/tests/fixtures/maps/cached_hashes_and_ledger.ts diff --git a/crates/interpreter/tests/fixtures/maps/ctor_from_entries.subm b/crates/submilli-engine/tests/fixtures/maps/ctor_from_entries.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/ctor_from_entries.subm rename to crates/submilli-engine/tests/fixtures/maps/ctor_from_entries.subm diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_for_of_non_iterable.subm b/crates/submilli-engine/tests/fixtures/maps/expect_error_for_of_non_iterable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_for_of_non_iterable.subm rename to crates/submilli-engine/tests/fixtures/maps/expect_error_for_of_non_iterable.subm diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_record_type.ts b/crates/submilli-engine/tests/fixtures/maps/expect_error_record_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_record_type.ts rename to crates/submilli-engine/tests/fixtures/maps/expect_error_record_type.ts diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_weakmap_type.subm b/crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_weakmap_type.subm rename to crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_type.subm diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_weakmap_value.subm b/crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_weakmap_value.subm rename to crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_value.subm diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_weakset_type.subm b/crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_type.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_weakset_type.subm rename to crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_type.subm diff --git a/crates/interpreter/tests/fixtures/maps/expect_error_weakset_value.subm b/crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_value.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/expect_error_weakset_value.subm rename to crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_value.subm diff --git a/crates/interpreter/tests/fixtures/maps/host_port_roundtrip.ts b/crates/submilli-engine/tests/fixtures/maps/host_port_roundtrip.ts similarity index 100% rename from crates/interpreter/tests/fixtures/maps/host_port_roundtrip.ts rename to crates/submilli-engine/tests/fixtures/maps/host_port_roundtrip.ts diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order.subm diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order_after_resize.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order_after_resize.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order_after_resize.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order_after_resize.subm diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order_delete_middle.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order_delete_middle.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order_delete_middle.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order_delete_middle.subm diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order_set.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order_set.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order_set.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order_set.subm diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order_set_after_resize.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order_set_after_resize.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order_set_after_resize.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order_set_after_resize.subm diff --git a/crates/interpreter/tests/fixtures/maps/insertion_order_set_delete_middle.subm b/crates/submilli-engine/tests/fixtures/maps/insertion_order_set_delete_middle.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/insertion_order_set_delete_middle.subm rename to crates/submilli-engine/tests/fixtures/maps/insertion_order_set_delete_middle.subm diff --git a/crates/interpreter/tests/fixtures/maps/iterate_for_of.subm b/crates/submilli-engine/tests/fixtures/maps/iterate_for_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/iterate_for_of.subm rename to crates/submilli-engine/tests/fixtures/maps/iterate_for_of.subm diff --git a/crates/interpreter/tests/fixtures/maps/iterate_iterator_method.subm b/crates/submilli-engine/tests/fixtures/maps/iterate_iterator_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/iterate_iterator_method.subm rename to crates/submilli-engine/tests/fixtures/maps/iterate_iterator_method.subm diff --git a/crates/interpreter/tests/fixtures/maps/iterate_set_iterator_method.subm b/crates/submilli-engine/tests/fixtures/maps/iterate_set_iterator_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/iterate_set_iterator_method.subm rename to crates/submilli-engine/tests/fixtures/maps/iterate_set_iterator_method.subm diff --git a/crates/interpreter/tests/fixtures/maps/iterator_concurrent.subm b/crates/submilli-engine/tests/fixtures/maps/iterator_concurrent.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/iterator_concurrent.subm rename to crates/submilli-engine/tests/fixtures/maps/iterator_concurrent.subm diff --git a/crates/interpreter/tests/fixtures/maps/iterator_sees_later_sets.subm b/crates/submilli-engine/tests/fixtures/maps/iterator_sees_later_sets.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/iterator_sees_later_sets.subm rename to crates/submilli-engine/tests/fixtures/maps/iterator_sees_later_sets.subm diff --git a/crates/interpreter/tests/fixtures/maps/keys_values_entries_iterators.subm b/crates/submilli-engine/tests/fixtures/maps/keys_values_entries_iterators.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/keys_values_entries_iterators.subm rename to crates/submilli-engine/tests/fixtures/maps/keys_values_entries_iterators.subm diff --git a/crates/interpreter/tests/fixtures/maps/number_keys.subm b/crates/submilli-engine/tests/fixtures/maps/number_keys.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/number_keys.subm rename to crates/submilli-engine/tests/fixtures/maps/number_keys.subm diff --git a/crates/interpreter/tests/fixtures/maps/object_keys.subm b/crates/submilli-engine/tests/fixtures/maps/object_keys.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/object_keys.subm rename to crates/submilli-engine/tests/fixtures/maps/object_keys.subm diff --git a/crates/interpreter/tests/fixtures/maps/object_values_get_field_access.subm b/crates/submilli-engine/tests/fixtures/maps/object_values_get_field_access.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/object_values_get_field_access.subm rename to crates/submilli-engine/tests/fixtures/maps/object_values_get_field_access.subm diff --git a/crates/interpreter/tests/fixtures/maps/phase2_typecheck.subm b/crates/submilli-engine/tests/fixtures/maps/phase2_typecheck.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/phase2_typecheck.subm rename to crates/submilli-engine/tests/fixtures/maps/phase2_typecheck.subm diff --git a/crates/interpreter/tests/fixtures/maps/phase6_for_of_typecheck.subm b/crates/submilli-engine/tests/fixtures/maps/phase6_for_of_typecheck.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/phase6_for_of_typecheck.subm rename to crates/submilli-engine/tests/fixtures/maps/phase6_for_of_typecheck.subm diff --git a/crates/interpreter/tests/fixtures/maps/postfix_chain_on_new.subm b/crates/submilli-engine/tests/fixtures/maps/postfix_chain_on_new.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/postfix_chain_on_new.subm rename to crates/submilli-engine/tests/fixtures/maps/postfix_chain_on_new.subm diff --git a/crates/interpreter/tests/fixtures/maps/resize.subm b/crates/submilli-engine/tests/fixtures/maps/resize.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/resize.subm rename to crates/submilli-engine/tests/fixtures/maps/resize.subm diff --git a/crates/interpreter/tests/fixtures/maps/set_basic.subm b/crates/submilli-engine/tests/fixtures/maps/set_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/set_basic.subm rename to crates/submilli-engine/tests/fixtures/maps/set_basic.subm diff --git a/crates/interpreter/tests/fixtures/maps/set_ctor_from_values.subm b/crates/submilli-engine/tests/fixtures/maps/set_ctor_from_values.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/set_ctor_from_values.subm rename to crates/submilli-engine/tests/fixtures/maps/set_ctor_from_values.subm diff --git a/crates/interpreter/tests/fixtures/maps/set_host_port_roundtrip.ts b/crates/submilli-engine/tests/fixtures/maps/set_host_port_roundtrip.ts similarity index 100% rename from crates/interpreter/tests/fixtures/maps/set_host_port_roundtrip.ts rename to crates/submilli-engine/tests/fixtures/maps/set_host_port_roundtrip.ts diff --git a/crates/interpreter/tests/fixtures/maps/set_iterate.subm b/crates/submilli-engine/tests/fixtures/maps/set_iterate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/set_iterate.subm rename to crates/submilli-engine/tests/fixtures/maps/set_iterate.subm diff --git a/crates/interpreter/tests/fixtures/maps/set_keys_values_entries_iterators.subm b/crates/submilli-engine/tests/fixtures/maps/set_keys_values_entries_iterators.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/set_keys_values_entries_iterators.subm rename to crates/submilli-engine/tests/fixtures/maps/set_keys_values_entries_iterators.subm diff --git a/crates/interpreter/tests/fixtures/maps/tombstone_reclamation.ts b/crates/submilli-engine/tests/fixtures/maps/tombstone_reclamation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/maps/tombstone_reclamation.ts rename to crates/submilli-engine/tests/fixtures/maps/tombstone_reclamation.ts diff --git a/crates/interpreter/tests/fixtures/maps/tombstone_reuse.subm b/crates/submilli-engine/tests/fixtures/maps/tombstone_reuse.subm similarity index 100% rename from crates/interpreter/tests/fixtures/maps/tombstone_reuse.subm rename to crates/submilli-engine/tests/fixtures/maps/tombstone_reuse.subm diff --git a/crates/interpreter/tests/fixtures/math_basic.subm b/crates/submilli-engine/tests/fixtures/math_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_basic.subm rename to crates/submilli-engine/tests/fixtures/math_basic.subm diff --git a/crates/interpreter/tests/fixtures/math_constants.subm b/crates/submilli-engine/tests/fixtures/math_constants.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_constants.subm rename to crates/submilli-engine/tests/fixtures/math_constants.subm diff --git a/crates/interpreter/tests/fixtures/math_hypot.subm b/crates/submilli-engine/tests/fixtures/math_hypot.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_hypot.subm rename to crates/submilli-engine/tests/fixtures/math_hypot.subm diff --git a/crates/interpreter/tests/fixtures/math_pi.subm b/crates/submilli-engine/tests/fixtures/math_pi.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_pi.subm rename to crates/submilli-engine/tests/fixtures/math_pi.subm diff --git a/crates/interpreter/tests/fixtures/math_random.subm b/crates/submilli-engine/tests/fixtures/math_random.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_random.subm rename to crates/submilli-engine/tests/fixtures/math_random.subm diff --git a/crates/interpreter/tests/fixtures/math_transcendentals.subm b/crates/submilli-engine/tests/fixtures/math_transcendentals.subm similarity index 100% rename from crates/interpreter/tests/fixtures/math_transcendentals.subm rename to crates/submilli-engine/tests/fixtures/math_transcendentals.subm diff --git a/crates/interpreter/tests/fixtures/method_call_through_string_key.ts b/crates/submilli-engine/tests/fixtures/method_call_through_string_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/method_call_through_string_key.ts rename to crates/submilli-engine/tests/fixtures/method_call_through_string_key.ts diff --git a/crates/interpreter/tests/fixtures/method_lift_substitutes_receiver_args.ts b/crates/submilli-engine/tests/fixtures/method_lift_substitutes_receiver_args.ts similarity index 100% rename from crates/interpreter/tests/fixtures/method_lift_substitutes_receiver_args.ts rename to crates/submilli-engine/tests/fixtures/method_lift_substitutes_receiver_args.ts diff --git a/crates/interpreter/tests/fixtures/module_let_narrowing_reads_live_after_call.ts b/crates/submilli-engine/tests/fixtures/module_let_narrowing_reads_live_after_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/module_let_narrowing_reads_live_after_call.ts rename to crates/submilli-engine/tests/fixtures/module_let_narrowing_reads_live_after_call.ts diff --git a/crates/interpreter/tests/fixtures/module_variable_before_initialization.ts b/crates/submilli-engine/tests/fixtures/module_variable_before_initialization.ts similarity index 100% rename from crates/interpreter/tests/fixtures/module_variable_before_initialization.ts rename to crates/submilli-engine/tests/fixtures/module_variable_before_initialization.ts diff --git a/crates/interpreter/tests/fixtures/multi/aliased_enum_import/lib.ts b/crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/aliased_enum_import/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/aliased_enum_import/m_enum.ts b/crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/m_enum.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/aliased_enum_import/m_enum.ts rename to crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/m_enum.ts diff --git a/crates/interpreter/tests/fixtures/multi/default_param_cross_module/lib.ts b/crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/default_param_cross_module/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/default_param_cross_module/util.ts b/crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/util.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/default_param_cross_module/util.ts rename to crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/util.ts diff --git a/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts b/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm b/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts b/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts rename to crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts diff --git a/crates/interpreter/tests/fixtures/multi/errors/cycle/b.subm b/crates/submilli-engine/tests/fixtures/multi/errors/cycle/b.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/cycle/b.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/cycle/b.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/cycle/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/cycle/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/cycle/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/cycle/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/main_decl/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/main_decl/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/main_decl/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/main_decl/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/missing_module/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/missing_module/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/missing_module/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/missing_module/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/private_symbol/lib.subm b/crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/private_symbol/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/errors/private_symbol/util.subm b/crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/errors/private_symbol/util.subm rename to crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_direct_documented/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_documented/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_direct_documented/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_documented/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_direct_missing/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_missing/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_direct_missing/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_missing/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_interface_member/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_interface_member/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_interface_member/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_interface_member/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_internal_helper/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_internal_helper/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_internal_helper/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_internal_helper/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/util.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/util.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/util.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/util.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/lib.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/util.ts b/crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/util.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/util.ts rename to crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/util.ts diff --git a/crates/interpreter/tests/fixtures/multi/exported_function_type_surface/lib.subm b/crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_function_type_surface/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/exported_function_type_surface/util.subm b/crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/exported_function_type_surface/util.subm rename to crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/namespace_import/lib.subm b/crates/submilli-engine/tests/fixtures/multi/namespace_import/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/namespace_import/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/namespace_import/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/namespace_import/util.subm b/crates/submilli-engine/tests/fixtures/multi/namespace_import/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/namespace_import/util.subm rename to crates/submilli-engine/tests/fixtures/multi/namespace_import/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm b/crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm b/crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm rename to crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/reexport_basic/lib.subm b/crates/submilli-engine/tests/fixtures/multi/reexport_basic/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/reexport_basic/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/reexport_basic/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/reexport_basic/util.subm b/crates/submilli-engine/tests/fixtures/multi/reexport_basic/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/reexport_basic/util.subm rename to crates/submilli-engine/tests/fixtures/multi/reexport_basic/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/reserved_word_export_names/lib.ts b/crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/reserved_word_export_names/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/reserved_word_export_names/values.ts b/crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/values.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/reserved_word_export_names/values.ts rename to crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/values.ts diff --git a/crates/interpreter/tests/fixtures/multi/sibling_import/lib.subm b/crates/submilli-engine/tests/fixtures/multi/sibling_import/lib.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/sibling_import/lib.subm rename to crates/submilli-engine/tests/fixtures/multi/sibling_import/lib.subm diff --git a/crates/interpreter/tests/fixtures/multi/sibling_import/util.subm b/crates/submilli-engine/tests/fixtures/multi/sibling_import/util.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/sibling_import/util.subm rename to crates/submilli-engine/tests/fixtures/multi/sibling_import/util.subm diff --git a/crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts b/crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts b/crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts rename to crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts diff --git a/crates/interpreter/tests/fixtures/multi/ts_mixed/lib.ts b/crates/submilli-engine/tests/fixtures/multi/ts_mixed/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/ts_mixed/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/ts_mixed/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/ts_mixed/wrap.subm b/crates/submilli-engine/tests/fixtures/multi/ts_mixed/wrap.subm similarity index 100% rename from crates/interpreter/tests/fixtures/multi/ts_mixed/wrap.subm rename to crates/submilli-engine/tests/fixtures/multi/ts_mixed/wrap.subm diff --git a/crates/interpreter/tests/fixtures/multi/type_only_reexport/lib.ts b/crates/submilli-engine/tests/fixtures/multi/type_only_reexport/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/type_only_reexport/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/type_only_reexport/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/type_only_reexport/util.ts b/crates/submilli-engine/tests/fixtures/multi/type_only_reexport/util.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/type_only_reexport/util.ts rename to crates/submilli-engine/tests/fixtures/multi/type_only_reexport/util.ts diff --git a/crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/lib.ts b/crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/lib.ts rename to crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/lib.ts diff --git a/crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/widget.ts b/crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/widget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/widget.ts rename to crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/widget.ts diff --git a/crates/interpreter/tests/fixtures/mvp_greet.subm b/crates/submilli-engine/tests/fixtures/mvp_greet.subm similarity index 100% rename from crates/interpreter/tests/fixtures/mvp_greet.subm rename to crates/submilli-engine/tests/fixtures/mvp_greet.subm diff --git a/crates/interpreter/tests/fixtures/namespace_shadowed_by_top_level.ts b/crates/submilli-engine/tests/fixtures/namespace_shadowed_by_top_level.ts similarity index 100% rename from crates/interpreter/tests/fixtures/namespace_shadowed_by_top_level.ts rename to crates/submilli-engine/tests/fixtures/namespace_shadowed_by_top_level.ts diff --git a/crates/interpreter/tests/fixtures/nan_local_binding_not_flagged.ts b/crates/submilli-engine/tests/fixtures/nan_local_binding_not_flagged.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nan_local_binding_not_flagged.ts rename to crates/submilli-engine/tests/fixtures/nan_local_binding_not_flagged.ts diff --git a/crates/interpreter/tests/fixtures/narrowed_boxed_binding_read.ts b/crates/submilli-engine/tests/fixtures/narrowed_boxed_binding_read.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowed_boxed_binding_read.ts rename to crates/submilli-engine/tests/fixtures/narrowed_boxed_binding_read.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/aliased_conditions_narrow.ts b/crates/submilli-engine/tests/fixtures/narrowing/aliased_conditions_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/aliased_conditions_narrow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/aliased_conditions_narrow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/array_isarray_narrows.subm b/crates/submilli-engine/tests/fixtures/narrowing/array_isarray_narrows.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/array_isarray_narrows.subm rename to crates/submilli-engine/tests/fixtures/narrowing/array_isarray_narrows.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/array_isarray_on_generic.subm b/crates/submilli-engine/tests/fixtures/narrowing/array_isarray_on_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/array_isarray_on_generic.subm rename to crates/submilli-engine/tests/fixtures/narrowing/array_isarray_on_generic.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts b/crates/submilli-engine/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts rename to crates/submilli-engine/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/assign_narrowing_survives_join.ts b/crates/submilli-engine/tests/fixtures/narrowing/assign_narrowing_survives_join.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assign_narrowing_survives_join.ts rename to crates/submilli-engine/tests/fixtures/narrowing/assign_narrowing_survives_join.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/assign_narrows_block_tail.subm b/crates/submilli-engine/tests/fixtures/narrowing/assign_narrows_block_tail.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assign_narrows_block_tail.subm rename to crates/submilli-engine/tests/fixtures/narrowing/assign_narrows_block_tail.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/assign_sibling_invalidates.subm b/crates/submilli-engine/tests/fixtures/narrowing/assign_sibling_invalidates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assign_sibling_invalidates.subm rename to crates/submilli-engine/tests/fixtures/narrowing/assign_sibling_invalidates.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/assign_then_call_invalidates.subm b/crates/submilli-engine/tests/fixtures/narrowing/assign_then_call_invalidates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assign_then_call_invalidates.subm rename to crates/submilli-engine/tests/fixtures/narrowing/assign_then_call_invalidates.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/assignment_value_truthiness.ts b/crates/submilli-engine/tests/fixtures/narrowing/assignment_value_truthiness.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/assignment_value_truthiness.ts rename to crates/submilli-engine/tests/fixtures/narrowing/assignment_value_truthiness.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts b/crates/submilli-engine/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts rename to crates/submilli-engine/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm b/crates/submilli-engine/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm rename to crates/submilli-engine/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm b/crates/submilli-engine/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm rename to crates/submilli-engine/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/call_rereads_field_path.ts b/crates/submilli-engine/tests/fixtures/narrowing/call_rereads_field_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/call_rereads_field_path.ts rename to crates/submilli-engine/tests/fixtures/narrowing/call_rereads_field_path.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/captured_mutator_write_back.ts b/crates/submilli-engine/tests/fixtures/narrowing/captured_mutator_write_back.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/captured_mutator_write_back.ts rename to crates/submilli-engine/tests/fixtures/narrowing/captured_mutator_write_back.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/chained_short_circuit.subm b/crates/submilli-engine/tests/fixtures/narrowing/chained_short_circuit.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/chained_short_circuit.subm rename to crates/submilli-engine/tests/fixtures/narrowing/chained_short_circuit.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/class_field_and_chain.ts b/crates/submilli-engine/tests/fixtures/narrowing/class_field_and_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/class_field_and_chain.ts rename to crates/submilli-engine/tests/fixtures/narrowing/class_field_and_chain.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/class_field_nested_if.ts b/crates/submilli-engine/tests/fixtures/narrowing/class_field_nested_if.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/class_field_nested_if.ts rename to crates/submilli-engine/tests/fixtures/narrowing/class_field_nested_if.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/class_private_field_same_module.ts b/crates/submilli-engine/tests/fixtures/narrowing/class_private_field_same_module.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/class_private_field_same_module.ts rename to crates/submilli-engine/tests/fixtures/narrowing/class_private_field_same_module.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/closure_last_assignment.ts b/crates/submilli-engine/tests/fixtures/narrowing/closure_last_assignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/closure_last_assignment.ts rename to crates/submilli-engine/tests/fixtures/narrowing/closure_last_assignment.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/closure_reguards_field_path.ts b/crates/submilli-engine/tests/fixtures/narrowing/closure_reguards_field_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/closure_reguards_field_path.ts rename to crates/submilli-engine/tests/fixtures/narrowing/closure_reguards_field_path.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/computed_write_retains_literal_type.ts b/crates/submilli-engine/tests/fixtures/narrowing/computed_write_retains_literal_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/computed_write_retains_literal_type.ts rename to crates/submilli-engine/tests/fixtures/narrowing/computed_write_retains_literal_type.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_top_level.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_top_level.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_top_level.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_top_level.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/const_narrow_survives_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_survives_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/const_narrow_survives_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/const_narrow_survives_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/discriminant_kind_equality.subm b/crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_equality.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/discriminant_kind_equality.subm rename to crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_equality.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/discriminant_kind_inequality.subm b/crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_inequality.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/discriminant_kind_inequality.subm rename to crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_inequality.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/discriminant_member_sets.ts b/crates/submilli-engine/tests/fixtures/narrowing/discriminant_member_sets.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/discriminant_member_sets.ts rename to crates/submilli-engine/tests/fixtures/narrowing/discriminant_member_sets.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/discriminant_three_variants.subm b/crates/submilli-engine/tests/fixtures/narrowing/discriminant_three_variants.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/discriminant_three_variants.subm rename to crates/submilli-engine/tests/fixtures/narrowing/discriminant_three_variants.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts b/crates/submilli-engine/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts rename to crates/submilli-engine/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/dropped_index_path_hint.ts b/crates/submilli-engine/tests/fixtures/narrowing/dropped_index_path_hint.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/dropped_index_path_hint.ts rename to crates/submilli-engine/tests/fixtures/narrowing/dropped_index_path_hint.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/enum_discriminant_case.ts b/crates/submilli-engine/tests/fixtures/narrowing/enum_discriminant_case.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/enum_discriminant_case.ts rename to crates/submilli-engine/tests/fixtures/narrowing/enum_discriminant_case.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts b/crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts rename to crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts b/crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts rename to crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts b/crates/submilli-engine/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts rename to crates/submilli-engine/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/equality_between_unions.ts b/crates/submilli-engine/tests/fixtures/narrowing/equality_between_unions.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/equality_between_unions.ts rename to crates/submilli-engine/tests/fixtures/narrowing/equality_between_unions.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts b/crates/submilli-engine/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts rename to crates/submilli-engine/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_continue_write.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_continue_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_continue_write.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_continue_write.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_do.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_do.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_do.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_do.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_for.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_for.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_for.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_for.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_forof.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_forof.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_forof.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_forof.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_while.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_while.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_while.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_while.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_finally_break.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_finally_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_finally_break.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_finally_break.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_direct.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_direct.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_direct.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_direct.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_nested.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_nested.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_nested.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_nested.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_switch.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_switch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_switch.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_switch.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_try.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_try.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_try.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_try.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_update.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_update.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_update.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_update.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_cast.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_cast.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_cast.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_cast.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_index.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_index.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_index.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_index.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm b/crates/submilli-engine/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm rename to crates/submilli-engine/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/field_path_two_deep_structural.ts b/crates/submilli-engine/tests/fixtures/narrowing/field_path_two_deep_structural.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/field_path_two_deep_structural.ts rename to crates/submilli-engine/tests/fixtures/narrowing/field_path_two_deep_structural.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_clause_joins.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_clause_joins.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_clause_joins.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_clause_joins.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_condition_preserved.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_condition_preserved.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_condition_preserved.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_condition_preserved.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_do_break.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_do_break.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_do_break.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_do_break.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_for_condition_preserved.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_for_condition_preserved.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_for_condition_preserved.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_for_condition_preserved.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_join_820.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_join_820.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_join_820.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_join_820.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_join_898.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_join_898.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_join_898.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_join_898.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_join_901.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_join_901.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_join_901.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_join_901.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_join_902.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_join_902.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_join_902.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_join_902.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_loops.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_loops.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_loops.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_loops.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_numeric_source.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_numeric_source.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_numeric_source.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_numeric_source.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_switch_unmatched.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_switch_unmatched.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_switch_unmatched.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_switch_unmatched.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/flow_this_for.ts b/crates/submilli-engine/tests/fixtures/narrowing/flow_this_for.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/flow_this_for.ts rename to crates/submilli-engine/tests/fixtures/narrowing/flow_this_for.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts b/crates/submilli-engine/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts rename to crates/submilli-engine/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm b/crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm rename to crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm b/crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm rename to crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts b/crates/submilli-engine/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts rename to crates/submilli-engine/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts b/crates/submilli-engine/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts b/crates/submilli-engine/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts b/crates/submilli-engine/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts rename to crates/submilli-engine/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/function_union_assignment.ts b/crates/submilli-engine/tests/fixtures/narrowing/function_union_assignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/function_union_assignment.ts rename to crates/submilli-engine/tests/fixtures/narrowing/function_union_assignment.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/generic_class_box_of_box.ts b/crates/submilli-engine/tests/fixtures/narrowing/generic_class_box_of_box.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/generic_class_box_of_box.ts rename to crates/submilli-engine/tests/fixtures/narrowing/generic_class_box_of_box.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/global_field_paths.ts b/crates/submilli-engine/tests/fixtures/narrowing/global_field_paths.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/global_field_paths.ts rename to crates/submilli-engine/tests/fixtures/narrowing/global_field_paths.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/global_guard_mutation.ts b/crates/submilli-engine/tests/fixtures/narrowing/global_guard_mutation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/global_guard_mutation.ts rename to crates/submilli-engine/tests/fixtures/narrowing/global_guard_mutation.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/global_ternary_null.ts b/crates/submilli-engine/tests/fixtures/narrowing/global_ternary_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/global_ternary_null.ts rename to crates/submilli-engine/tests/fixtures/narrowing/global_ternary_null.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/guard_through_an_element.ts b/crates/submilli-engine/tests/fixtures/narrowing/guard_through_an_element.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/guard_through_an_element.ts rename to crates/submilli-engine/tests/fixtures/narrowing/guard_through_an_element.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/immediately_invoked_functions.ts b/crates/submilli-engine/tests/fixtures/narrowing/immediately_invoked_functions.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/immediately_invoked_functions.ts rename to crates/submilli-engine/tests/fixtures/narrowing/immediately_invoked_functions.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/in_operator_basic_object.subm b/crates/submilli-engine/tests/fixtures/narrowing/in_operator_basic_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/in_operator_basic_object.subm rename to crates/submilli-engine/tests/fixtures/narrowing/in_operator_basic_object.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/in_operator_dynamic_key.ts b/crates/submilli-engine/tests/fixtures/narrowing/in_operator_dynamic_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/in_operator_dynamic_key.ts rename to crates/submilli-engine/tests/fixtures/narrowing/in_operator_dynamic_key.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/in_operator_union_filter.subm b/crates/submilli-engine/tests/fixtures/narrowing/in_operator_union_filter.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/in_operator_union_filter.subm rename to crates/submilli-engine/tests/fixtures/narrowing/in_operator_union_filter.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/in_operator_unknown_chain.subm b/crates/submilli-engine/tests/fixtures/narrowing/in_operator_unknown_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/in_operator_unknown_chain.subm rename to crates/submilli-engine/tests/fixtures/narrowing/in_operator_unknown_chain.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/in_typeof_field_chain.subm b/crates/submilli-engine/tests/fixtures/narrowing/in_typeof_field_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/in_typeof_field_chain.subm rename to crates/submilli-engine/tests/fixtures/narrowing/in_typeof_field_chain.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/index_by_constant_key.ts b/crates/submilli-engine/tests/fixtures/narrowing/index_by_constant_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/index_by_constant_key.ts rename to crates/submilli-engine/tests/fixtures/narrowing/index_by_constant_key.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/index_path_and_chain.ts b/crates/submilli-engine/tests/fixtures/narrowing/index_path_and_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/index_path_and_chain.ts rename to crates/submilli-engine/tests/fixtures/narrowing/index_path_and_chain.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/interface_field_holding_class.ts b/crates/submilli-engine/tests/fixtures/narrowing/interface_field_holding_class.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/interface_field_holding_class.ts rename to crates/submilli-engine/tests/fixtures/narrowing/interface_field_holding_class.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_785_chain.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_785_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_785_chain.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_785_chain.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_785_switch.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_785_switch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_785_switch.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_785_switch.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_786.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_786.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_786.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_786.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_816.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_816.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_816.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_816.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_889.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_889.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_889.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_889.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_890_anonymous_lift.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_890_anonymous_lift.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_890_anonymous_lift.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_890_anonymous_lift.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_890_predicate_lift.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_890_predicate_lift.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_890_predicate_lift.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_890_predicate_lift.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_929.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_929.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_929.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_929.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_929_expect_error_union.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_929_expect_error_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_929_expect_error_union.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_929_expect_error_union.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948_composed.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948_composed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948_composed.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948_composed.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948_discriminant.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948_discriminant.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948_discriminant.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948_discriminant.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948_nested.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948_nested.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948_nested.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948_nested.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948_switch.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948_switch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948_switch.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948_switch.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/issue_948_union_refined.ts b/crates/submilli-engine/tests/fixtures/narrowing/issue_948_union_refined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/issue_948_union_refined.ts rename to crates/submilli-engine/tests/fixtures/narrowing/issue_948_union_refined.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/join_points_keep_narrowing.ts b/crates/submilli-engine/tests/fixtures/narrowing/join_points_keep_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/join_points_keep_narrowing.ts rename to crates/submilli-engine/tests/fixtures/narrowing/join_points_keep_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts b/crates/submilli-engine/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts rename to crates/submilli-engine/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts b/crates/submilli-engine/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts rename to crates/submilli-engine/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/literal_index_guard.ts b/crates/submilli-engine/tests/fixtures/narrowing/literal_index_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/literal_index_guard.ts rename to crates/submilli-engine/tests/fixtures/narrowing/literal_index_guard.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_assignment_result.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_assignment_result.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_assignment_result.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_assignment_result.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_big_bom.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_big_bom.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_big_bom.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_big_bom.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_big_separator.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_big_separator.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_big_separator.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_big_separator.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_boolean_literal_result.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_boolean_literal_result.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_boolean_literal_result.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_boolean_literal_result.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_call_order.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_call_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_call_order.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_call_order.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_function_reference.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_function_reference.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_function_reference.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_function_reference.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_index_conversion.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_index_conversion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_index_conversion.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_index_conversion.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_index_noncanonical.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_index_noncanonical.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_index_noncanonical.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_index_noncanonical.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_json_arguments.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_json_arguments.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_json_arguments.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_json_arguments.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_map_return.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_map_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_map_return.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_map_return.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_builtin_rest.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_builtin_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_builtin_rest.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_builtin_rest.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_class_rest.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_class_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_class_rest.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_class_rest.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_default.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_default.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_default.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_fresh_default.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_fresh_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_fresh_default.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_fresh_default.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_function_default.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_function_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_function_default.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_function_default.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_member_rest.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_member_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_member_rest.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_member_rest.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_number_predicate.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_number_predicate.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_number_predicate.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_number_predicate.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_optional_shape_analysis.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_optional_shape_analysis.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_optional_shape_analysis.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_optional_shape_analysis.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/live_postfix_value.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_postfix_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_postfix_value.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_postfix_value.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_pow_boundary.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_pow_boundary.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_pow_boundary.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_pow_boundary.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_pow_nan.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_pow_nan.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_pow_nan.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_pow_nan.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_generic.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_generic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_generic.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_generic.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_includes.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_includes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_includes.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_includes.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_length.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_length.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_length.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_length.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_method.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_method.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_method.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_optional.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_optional.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_optional.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_receiver_to_string.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_to_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_receiver_to_string.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_receiver_to_string.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_regex_argument.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_regex_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_regex_argument.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_regex_argument.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_runtime_values.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_runtime_values.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_runtime_values.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_runtime_values.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_search_order.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_search_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_search_order.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_search_order.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_string_argument.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_string_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_string_argument.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_string_argument.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_valueof_conversion.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_valueof_conversion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_valueof_conversion.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_valueof_conversion.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_values_packages/app/main.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_values_packages/app/main.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/app/main.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_values_packages/library/lib.ts b/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/library/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_values_packages/library/lib.ts rename to crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/library/lib.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/live_values_packages/packages.manifest b/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/live_values_packages/packages.manifest rename to crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/packages.manifest diff --git a/crates/interpreter/tests/fixtures/narrowing/loop_exit_body_local_join.ts b/crates/submilli-engine/tests/fixtures/narrowing/loop_exit_body_local_join.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/loop_exit_body_local_join.ts rename to crates/submilli-engine/tests/fixtures/narrowing/loop_exit_body_local_join.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts b/crates/submilli-engine/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts rename to crates/submilli-engine/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/loop_join_after_continue.ts b/crates/submilli-engine/tests/fixtures/narrowing/loop_join_after_continue.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/loop_join_after_continue.ts rename to crates/submilli-engine/tests/fixtures/narrowing/loop_join_after_continue.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/loop_tail_narrowings.ts b/crates/submilli-engine/tests/fixtures/narrowing/loop_tail_narrowings.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/loop_tail_narrowings.ts rename to crates/submilli-engine/tests/fixtures/narrowing/loop_tail_narrowings.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/loop_wrapped_body_forms.ts b/crates/submilli-engine/tests/fixtures/narrowing/loop_wrapped_body_forms.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/loop_wrapped_body_forms.ts rename to crates/submilli-engine/tests/fixtures/narrowing/loop_wrapped_body_forms.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm b/crates/submilli-engine/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm rename to crates/submilli-engine/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts b/crates/submilli-engine/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts rename to crates/submilli-engine/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/nested_block_narrowing.subm b/crates/submilli-engine/tests/fixtures/narrowing/nested_block_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/nested_block_narrowing.subm rename to crates/submilli-engine/tests/fixtures/narrowing/nested_block_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/nested_shadow_reuse.ts b/crates/submilli-engine/tests/fixtures/narrowing/nested_shadow_reuse.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/nested_shadow_reuse.ts rename to crates/submilli-engine/tests/fixtures/narrowing/nested_shadow_reuse.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/never_array_hints_later_elements.ts b/crates/submilli-engine/tests/fixtures/narrowing/never_array_hints_later_elements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/never_array_hints_later_elements.ts rename to crates/submilli-engine/tests/fixtures/narrowing/never_array_hints_later_elements.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/never_field_in_object_literal.ts b/crates/submilli-engine/tests/fixtures/narrowing/never_field_in_object_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/never_field_in_object_literal.ts rename to crates/submilli-engine/tests/fixtures/narrowing/never_field_in_object_literal.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/never_operand_in_dead_code.ts b/crates/submilli-engine/tests/fixtures/narrowing/never_operand_in_dead_code.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/never_operand_in_dead_code.ts rename to crates/submilli-engine/tests/fixtures/narrowing/never_operand_in_dead_code.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/never_read_in_closure.ts b/crates/submilli-engine/tests/fixtures/narrowing/never_read_in_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/never_read_in_closure.ts rename to crates/submilli-engine/tests/fixtures/narrowing/never_read_in_closure.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/nominal_union_field_access.ts b/crates/submilli-engine/tests/fixtures/narrowing/nominal_union_field_access.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/nominal_union_field_access.ts rename to crates/submilli-engine/tests/fixtures/narrowing/nominal_union_field_access.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/non_null_assertion.ts b/crates/submilli-engine/tests/fixtures/narrowing/non_null_assertion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/non_null_assertion.ts rename to crates/submilli-engine/tests/fixtures/narrowing/non_null_assertion.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts b/crates/submilli-engine/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts rename to crates/submilli-engine/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/not_truthiness_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/not_truthiness_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/not_truthiness_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/not_truthiness_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/null_comparison_guards.ts b/crates/submilli-engine/tests/fixtures/narrowing/null_comparison_guards.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/null_comparison_guards.ts rename to crates/submilli-engine/tests/fixtures/narrowing/null_comparison_guards.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/null_eq_else.subm b/crates/submilli-engine/tests/fixtures/narrowing/null_eq_else.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/null_eq_else.subm rename to crates/submilli-engine/tests/fixtures/narrowing/null_eq_else.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/null_global_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/null_global_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/null_global_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/null_global_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/null_neq_then.subm b/crates/submilli-engine/tests/fixtures/narrowing/null_neq_then.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/null_neq_then.subm rename to crates/submilli-engine/tests/fixtures/narrowing/null_neq_then.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/null_neq_unbox.subm b/crates/submilli-engine/tests/fixtures/narrowing/null_neq_unbox.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/null_neq_unbox.subm rename to crates/submilli-engine/tests/fixtures/narrowing/null_neq_unbox.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/nullable_rw_target_write_out.ts b/crates/submilli-engine/tests/fixtures/narrowing/nullable_rw_target_write_out.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/nullable_rw_target_write_out.ts rename to crates/submilli-engine/tests/fixtures/narrowing/nullable_rw_target_write_out.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/nullable_smoke.subm b/crates/submilli-engine/tests/fixtures/narrowing/nullable_smoke.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/nullable_smoke.subm rename to crates/submilli-engine/tests/fixtures/narrowing/nullable_smoke.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/operator_narrowing.ts b/crates/submilli-engine/tests/fixtures/narrowing/operator_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/operator_narrowing.ts rename to crates/submilli-engine/tests/fixtures/narrowing/operator_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm b/crates/submilli-engine/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm rename to crates/submilli-engine/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm b/crates/submilli-engine/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm rename to crates/submilli-engine/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/postfix_narrowed.ts b/crates/submilli-engine/tests/fixtures/narrowing/postfix_narrowed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/postfix_narrowed.ts rename to crates/submilli-engine/tests/fixtures/narrowing/postfix_narrowed.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_chained_post_if.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_chained_post_if.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_chained_post_if.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_chained_post_if.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_post_if.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_post_if.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_post_if.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_post_if.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_eq_else.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_eq_else.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_eq_else.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_eq_else.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_neq_then.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_neq_then.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/property_path_neq_then_post_if.subm b/crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then_post_if.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/property_path_neq_then_post_if.subm rename to crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then_post_if.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/reassign_same_type_rewidens.ts b/crates/submilli-engine/tests/fixtures/narrowing/reassign_same_type_rewidens.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/reassign_same_type_rewidens.ts rename to crates/submilli-engine/tests/fixtures/narrowing/reassign_same_type_rewidens.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/return_in_if_carries_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/return_in_if_carries_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/return_in_if_carries_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/return_in_if_carries_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/rules_out_every_value.ts b/crates/submilli-engine/tests/fixtures/narrowing/rules_out_every_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/rules_out_every_value.ts rename to crates/submilli-engine/tests/fixtures/narrowing/rules_out_every_value.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/short_circuit_and_narrows.subm b/crates/submilli-engine/tests/fixtures/narrowing/short_circuit_and_narrows.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/short_circuit_and_narrows.subm rename to crates/submilli-engine/tests/fixtures/narrowing/short_circuit_and_narrows.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/short_circuit_or_narrows.subm b/crates/submilli-engine/tests/fixtures/narrowing/short_circuit_or_narrows.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/short_circuit_or_narrows.subm rename to crates/submilli-engine/tests/fixtures/narrowing/short_circuit_or_narrows.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts b/crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts rename to crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/sibling_paths_three_idents.ts b/crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_three_idents.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/sibling_paths_three_idents.ts rename to crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_three_idents.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/switch_boolean_discriminant.ts b/crates/submilli-engine/tests/fixtures/narrowing/switch_boolean_discriminant.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/switch_boolean_discriminant.ts rename to crates/submilli-engine/tests/fixtures/narrowing/switch_boolean_discriminant.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts b/crates/submilli-engine/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts rename to crates/submilli-engine/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts b/crates/submilli-engine/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts rename to crates/submilli-engine/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/switch_without_default_falls_through.ts b/crates/submilli-engine/tests/fixtures/narrowing/switch_without_default_falls_through.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/switch_without_default_falls_through.ts rename to crates/submilli-engine/tests/fixtures/narrowing/switch_without_default_falls_through.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/ternary_and_interface_field.ts b/crates/submilli-engine/tests/fixtures/narrowing/ternary_and_interface_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/ternary_and_interface_field.ts rename to crates/submilli-engine/tests/fixtures/narrowing/ternary_and_interface_field.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/this_rooted_paths.ts b/crates/submilli-engine/tests/fixtures/narrowing/this_rooted_paths.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/this_rooted_paths.ts rename to crates/submilli-engine/tests/fixtures/narrowing/this_rooted_paths.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/truthiness_field_path_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/truthiness_field_path_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/truthiness_field_path_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/truthiness_field_path_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/truthiness_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/truthiness_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/truthiness_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/truthiness_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm b/crates/submilli-engine/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm rename to crates/submilli-engine/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm b/crates/submilli-engine/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm rename to crates/submilli-engine/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_aliased_union.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_aliased_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_aliased_union.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_aliased_union.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_boolean_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_boolean_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_boolean_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_boolean_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_field_path_else_branch.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_else_branch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_field_path_else_branch.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_else_branch.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_field_path_string.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_field_path_string.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_string.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts b/crates/submilli-engine/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_function_generic.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_function_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_function_generic.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_function_generic.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_function_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_function_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_function_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_function_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_number_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_number_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_number_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_number_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts b/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_object_generic.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_object_generic.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_object_generic.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_object_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_object_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_object_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_string_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_string_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_string_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_string_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_three_way_union.subm b/crates/submilli-engine/tests/fixtures/narrowing/typeof_three_way_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_three_way_union.subm rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_three_way_union.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/typeof_through_generic_alias.ts b/crates/submilli-engine/tests/fixtures/narrowing/typeof_through_generic_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/typeof_through_generic_alias.ts rename to crates/submilli-engine/tests/fixtures/narrowing/typeof_through_generic_alias.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_discriminant.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_discriminant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_discriminant.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_discriminant.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_else_branch.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_else_branch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_else_branch.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_else_branch.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_generic_strip_null.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_strip_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_generic_strip_null.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_strip_null.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_in_typeof.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_in_typeof.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_in_typeof.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_in_typeof.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_nullable.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_nullable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_nullable.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_nullable.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_primitive.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_primitive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_primitive.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_primitive.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/user_guard_type_alias.subm b/crates/submilli-engine/tests/fixtures/narrowing/user_guard_type_alias.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/user_guard_type_alias.subm rename to crates/submilli-engine/tests/fixtures/narrowing/user_guard_type_alias.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/while_body_local_continue_narrow.ts b/crates/submilli-engine/tests/fixtures/narrowing/while_body_local_continue_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_body_local_continue_narrow.ts rename to crates/submilli-engine/tests/fixtures/narrowing/while_body_local_continue_narrow.ts diff --git a/crates/interpreter/tests/fixtures/narrowing/while_body_narrowing.subm b/crates/submilli-engine/tests/fixtures/narrowing/while_body_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_body_narrowing.subm rename to crates/submilli-engine/tests/fixtures/narrowing/while_body_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/while_break_carries_narrow.subm b/crates/submilli-engine/tests/fixtures/narrowing/while_break_carries_narrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_break_carries_narrow.subm rename to crates/submilli-engine/tests/fixtures/narrowing/while_break_carries_narrow.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/while_break_two_paths_widens.subm b/crates/submilli-engine/tests/fixtures/narrowing/while_break_two_paths_widens.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_break_two_paths_widens.subm rename to crates/submilli-engine/tests/fixtures/narrowing/while_break_two_paths_widens.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/while_fixed_point_continue.subm b/crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_continue.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_fixed_point_continue.subm rename to crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_continue.subm diff --git a/crates/interpreter/tests/fixtures/narrowing/while_fixed_point_converges.subm b/crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_converges.subm similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing/while_fixed_point_converges.subm rename to crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_converges.subm diff --git a/crates/interpreter/tests/fixtures/narrowing_field_path_nested_region.ts b/crates/submilli-engine/tests/fixtures/narrowing_field_path_nested_region.ts similarity index 100% rename from crates/interpreter/tests/fixtures/narrowing_field_path_nested_region.ts rename to crates/submilli-engine/tests/fixtures/narrowing_field_path_nested_region.ts diff --git a/crates/interpreter/tests/fixtures/nested_function_default_param.ts b/crates/submilli-engine/tests/fixtures/nested_function_default_param.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nested_function_default_param.ts rename to crates/submilli-engine/tests/fixtures/nested_function_default_param.ts diff --git a/crates/interpreter/tests/fixtures/nested_function_reads_later_local.ts b/crates/submilli-engine/tests/fixtures/nested_function_reads_later_local.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nested_function_reads_later_local.ts rename to crates/submilli-engine/tests/fixtures/nested_function_reads_later_local.ts diff --git a/crates/interpreter/tests/fixtures/nested_function_top_level_block.ts b/crates/submilli-engine/tests/fixtures/nested_function_top_level_block.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nested_function_top_level_block.ts rename to crates/submilli-engine/tests/fixtures/nested_function_top_level_block.ts diff --git a/crates/interpreter/tests/fixtures/never/expect_error_never_falls_through.subm b/crates/submilli-engine/tests/fixtures/never/expect_error_never_falls_through.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/expect_error_never_falls_through.subm rename to crates/submilli-engine/tests/fixtures/never/expect_error_never_falls_through.subm diff --git a/crates/interpreter/tests/fixtures/never/expect_error_return_value_in_never_fn.subm b/crates/submilli-engine/tests/fixtures/never/expect_error_return_value_in_never_fn.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/expect_error_return_value_in_never_fn.subm rename to crates/submilli-engine/tests/fixtures/never/expect_error_return_value_in_never_fn.subm diff --git a/crates/interpreter/tests/fixtures/never/expect_error_value_into_never_slot.subm b/crates/submilli-engine/tests/fixtures/never/expect_error_value_into_never_slot.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/expect_error_value_into_never_slot.subm rename to crates/submilli-engine/tests/fixtures/never/expect_error_value_into_never_slot.subm diff --git a/crates/interpreter/tests/fixtures/never/never_assignable_to_string.subm b/crates/submilli-engine/tests/fixtures/never/never_assignable_to_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/never_assignable_to_string.subm rename to crates/submilli-engine/tests/fixtures/never/never_assignable_to_string.subm diff --git a/crates/interpreter/tests/fixtures/never/never_in_union.subm b/crates/submilli-engine/tests/fixtures/never/never_in_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/never_in_union.subm rename to crates/submilli-engine/tests/fixtures/never/never_in_union.subm diff --git a/crates/interpreter/tests/fixtures/never/never_return_throw.subm b/crates/submilli-engine/tests/fixtures/never/never_return_throw.subm similarity index 100% rename from crates/interpreter/tests/fixtures/never/never_return_throw.subm rename to crates/submilli-engine/tests/fixtures/never/never_return_throw.subm diff --git a/crates/interpreter/tests/fixtures/never_annotated_closure_in_void_slot.ts b/crates/submilli-engine/tests/fixtures/never_annotated_closure_in_void_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/never_annotated_closure_in_void_slot.ts rename to crates/submilli-engine/tests/fixtures/never_annotated_closure_in_void_slot.ts diff --git a/crates/interpreter/tests/fixtures/never_function_void_slot.ts b/crates/submilli-engine/tests/fixtures/never_function_void_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/never_function_void_slot.ts rename to crates/submilli-engine/tests/fixtures/never_function_void_slot.ts diff --git a/crates/interpreter/tests/fixtures/never_generic_callback.ts b/crates/submilli-engine/tests/fixtures/never_generic_callback.ts similarity index 100% rename from crates/interpreter/tests/fixtures/never_generic_callback.ts rename to crates/submilli-engine/tests/fixtures/never_generic_callback.ts diff --git a/crates/interpreter/tests/fixtures/never_operands.ts b/crates/submilli-engine/tests/fixtures/never_operands.ts similarity index 100% rename from crates/interpreter/tests/fixtures/never_operands.ts rename to crates/submilli-engine/tests/fixtures/never_operands.ts diff --git a/crates/interpreter/tests/fixtures/new_uint8array.subm b/crates/submilli-engine/tests/fixtures/new_uint8array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/new_uint8array.subm rename to crates/submilli-engine/tests/fixtures/new_uint8array.subm diff --git a/crates/interpreter/tests/fixtures/new_with_dotted_form.subm b/crates/submilli-engine/tests/fixtures/new_with_dotted_form.subm similarity index 100% rename from crates/interpreter/tests/fixtures/new_with_dotted_form.subm rename to crates/submilli-engine/tests/fixtures/new_with_dotted_form.subm diff --git a/crates/interpreter/tests/fixtures/no_panic_prelude_invariants.ts b/crates/submilli-engine/tests/fixtures/no_panic_prelude_invariants.ts similarity index 100% rename from crates/interpreter/tests/fixtures/no_panic_prelude_invariants.ts rename to crates/submilli-engine/tests/fixtures/no_panic_prelude_invariants.ts diff --git a/crates/interpreter/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts b/crates/submilli-engine/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts similarity index 100% rename from crates/interpreter/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts rename to crates/submilli-engine/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts diff --git a/crates/interpreter/tests/fixtures/null_discriminant_narrows.ts b/crates/submilli-engine/tests/fixtures/null_discriminant_narrows.ts similarity index 100% rename from crates/interpreter/tests/fixtures/null_discriminant_narrows.ts rename to crates/submilli-engine/tests/fixtures/null_discriminant_narrows.ts diff --git a/crates/interpreter/tests/fixtures/nullable_receiver_names_the_guard.ts b/crates/submilli-engine/tests/fixtures/nullable_receiver_names_the_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nullable_receiver_names_the_guard.ts rename to crates/submilli-engine/tests/fixtures/nullable_receiver_names_the_guard.ts diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/chained.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/chained.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/chained.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/chained.subm diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts b/crates/submilli-engine/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/simple.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/simple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/simple.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/simple.subm diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/void_right.ts b/crates/submilli-engine/tests/fixtures/nullish_coalescing/void_right.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/void_right.ts rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/void_right.ts diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/with_field.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/with_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/with_field.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/with_field.subm diff --git a/crates/interpreter/tests/fixtures/nullish_coalescing/with_parens_ok.subm b/crates/submilli-engine/tests/fixtures/nullish_coalescing/with_parens_ok.subm similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_coalescing/with_parens_ok.subm rename to crates/submilli-engine/tests/fixtures/nullish_coalescing/with_parens_ok.subm diff --git a/crates/interpreter/tests/fixtures/nullish_grouping_and_zero_literals.ts b/crates/submilli-engine/tests/fixtures/nullish_grouping_and_zero_literals.ts similarity index 100% rename from crates/interpreter/tests/fixtures/nullish_grouping_and_zero_literals.ts rename to crates/submilli-engine/tests/fixtures/nullish_grouping_and_zero_literals.ts diff --git a/crates/interpreter/tests/fixtures/number_global_predicates.subm b/crates/submilli-engine/tests/fixtures/number_global_predicates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_global_predicates.subm rename to crates/submilli-engine/tests/fixtures/number_global_predicates.subm diff --git a/crates/interpreter/tests/fixtures/number_parse_statics.subm b/crates/submilli-engine/tests/fixtures/number_parse_statics.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_parse_statics.subm rename to crates/submilli-engine/tests/fixtures/number_parse_statics.subm diff --git a/crates/interpreter/tests/fixtures/number_predicates_no_coercion.ts b/crates/submilli-engine/tests/fixtures/number_predicates_no_coercion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/number_predicates_no_coercion.ts rename to crates/submilli-engine/tests/fixtures/number_predicates_no_coercion.ts diff --git a/crates/interpreter/tests/fixtures/number_radix_strings.subm b/crates/submilli-engine/tests/fixtures/number_radix_strings.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_radix_strings.subm rename to crates/submilli-engine/tests/fixtures/number_radix_strings.subm diff --git a/crates/interpreter/tests/fixtures/number_static_constants.subm b/crates/submilli-engine/tests/fixtures/number_static_constants.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_static_constants.subm rename to crates/submilli-engine/tests/fixtures/number_static_constants.subm diff --git a/crates/interpreter/tests/fixtures/number_static_predicates.subm b/crates/submilli-engine/tests/fixtures/number_static_predicates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_static_predicates.subm rename to crates/submilli-engine/tests/fixtures/number_static_predicates.subm diff --git a/crates/interpreter/tests/fixtures/number_to_fixed.subm b/crates/submilli-engine/tests/fixtures/number_to_fixed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_to_fixed.subm rename to crates/submilli-engine/tests/fixtures/number_to_fixed.subm diff --git a/crates/interpreter/tests/fixtures/number_to_precision_exponential.subm b/crates/submilli-engine/tests/fixtures/number_to_precision_exponential.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_to_precision_exponential.subm rename to crates/submilli-engine/tests/fixtures/number_to_precision_exponential.subm diff --git a/crates/interpreter/tests/fixtures/number_to_string_radix.subm b/crates/submilli-engine/tests/fixtures/number_to_string_radix.subm similarity index 100% rename from crates/interpreter/tests/fixtures/number_to_string_radix.subm rename to crates/submilli-engine/tests/fixtures/number_to_string_radix.subm diff --git a/crates/interpreter/tests/fixtures/numeric_separators_and_decimal_point.ts b/crates/submilli-engine/tests/fixtures/numeric_separators_and_decimal_point.ts similarity index 100% rename from crates/interpreter/tests/fixtures/numeric_separators_and_decimal_point.ts rename to crates/submilli-engine/tests/fixtures/numeric_separators_and_decimal_point.ts diff --git a/crates/interpreter/tests/fixtures/object_function_typed_field.subm b/crates/submilli-engine/tests/fixtures/object_function_typed_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/object_function_typed_field.subm rename to crates/submilli-engine/tests/fixtures/object_function_typed_field.subm diff --git a/crates/interpreter/tests/fixtures/object_is.subm b/crates/submilli-engine/tests/fixtures/object_is.subm similarity index 100% rename from crates/interpreter/tests/fixtures/object_is.subm rename to crates/submilli-engine/tests/fixtures/object_is.subm diff --git a/crates/interpreter/tests/fixtures/object_key_reassigned_wider_field.ts b/crates/submilli-engine/tests/fixtures/object_key_reassigned_wider_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_key_reassigned_wider_field.ts rename to crates/submilli-engine/tests/fixtures/object_key_reassigned_wider_field.ts diff --git a/crates/interpreter/tests/fixtures/object_literal_dictionary_union.ts b/crates/submilli-engine/tests/fixtures/object_literal_dictionary_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_literal_dictionary_union.ts rename to crates/submilli-engine/tests/fixtures/object_literal_dictionary_union.ts diff --git a/crates/interpreter/tests/fixtures/object_literal_evaluation_order.ts b/crates/submilli-engine/tests/fixtures/object_literal_evaluation_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_literal_evaluation_order.ts rename to crates/submilli-engine/tests/fixtures/object_literal_evaluation_order.ts diff --git a/crates/interpreter/tests/fixtures/object_literal_into_nullable_tagged_union.ts b/crates/submilli-engine/tests/fixtures/object_literal_into_nullable_tagged_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_literal_into_nullable_tagged_union.ts rename to crates/submilli-engine/tests/fixtures/object_literal_into_nullable_tagged_union.ts diff --git a/crates/interpreter/tests/fixtures/object_literal_normalization_at_depth.ts b/crates/submilli-engine/tests/fixtures/object_literal_normalization_at_depth.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_literal_normalization_at_depth.ts rename to crates/submilli-engine/tests/fixtures/object_literal_normalization_at_depth.ts diff --git a/crates/interpreter/tests/fixtures/object_literal_subtype_reduction.ts b/crates/submilli-engine/tests/fixtures/object_literal_subtype_reduction.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_literal_subtype_reduction.ts rename to crates/submilli-engine/tests/fixtures/object_literal_subtype_reduction.ts diff --git a/crates/interpreter/tests/fixtures/object_rest_copies.ts b/crates/submilli-engine/tests/fixtures/object_rest_copies.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_rest_copies.ts rename to crates/submilli-engine/tests/fixtures/object_rest_copies.ts diff --git a/crates/interpreter/tests/fixtures/object_rest_let.ts b/crates/submilli-engine/tests/fixtures/object_rest_let.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_rest_let.ts rename to crates/submilli-engine/tests/fixtures/object_rest_let.ts diff --git a/crates/interpreter/tests/fixtures/object_spread_widened_union.ts b/crates/submilli-engine/tests/fixtures/object_spread_widened_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_spread_widened_union.ts rename to crates/submilli-engine/tests/fixtures/object_spread_widened_union.ts diff --git a/crates/interpreter/tests/fixtures/object_statics.subm b/crates/submilli-engine/tests/fixtures/object_statics.subm similarity index 100% rename from crates/interpreter/tests/fixtures/object_statics.subm rename to crates/submilli-engine/tests/fixtures/object_statics.subm diff --git a/crates/interpreter/tests/fixtures/object_statics_host.ts b/crates/submilli-engine/tests/fixtures/object_statics_host.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_statics_host.ts rename to crates/submilli-engine/tests/fixtures/object_statics_host.ts diff --git a/crates/interpreter/tests/fixtures/object_type_member_named_new.ts b/crates/submilli-engine/tests/fixtures/object_type_member_named_new.ts similarity index 100% rename from crates/interpreter/tests/fixtures/object_type_member_named_new.ts rename to crates/submilli-engine/tests/fixtures/object_type_member_named_new.ts diff --git a/crates/interpreter/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts b/crates/submilli-engine/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts rename to crates/submilli-engine/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_missing_field.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_missing_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_field_assign_missing_field.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_missing_field.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_non_object.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_non_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_field_assign_non_object.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_non_object.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_invalid_assign_target.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_invalid_assign_target.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_invalid_assign_target.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_invalid_assign_target.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_union_missing_field.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_union_missing_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_union_missing_field.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_union_missing_field.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm diff --git a/crates/interpreter/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm b/crates/submilli-engine/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm rename to crates/submilli-engine/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm diff --git a/crates/interpreter/tests/fixtures/objects/field_assign_basic.subm b/crates/submilli-engine/tests/fixtures/objects/field_assign_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/field_assign_basic.subm rename to crates/submilli-engine/tests/fixtures/objects/field_assign_basic.subm diff --git a/crates/interpreter/tests/fixtures/objects/field_assign_const_binding.subm b/crates/submilli-engine/tests/fixtures/objects/field_assign_const_binding.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/field_assign_const_binding.subm rename to crates/submilli-engine/tests/fixtures/objects/field_assign_const_binding.subm diff --git a/crates/interpreter/tests/fixtures/objects/field_assign_nested.subm b/crates/submilli-engine/tests/fixtures/objects/field_assign_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/field_assign_nested.subm rename to crates/submilli-engine/tests/fixtures/objects/field_assign_nested.subm diff --git a/crates/interpreter/tests/fixtures/objects/field_assign_string.subm b/crates/submilli-engine/tests/fixtures/objects/field_assign_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/field_assign_string.subm rename to crates/submilli-engine/tests/fixtures/objects/field_assign_string.subm diff --git a/crates/interpreter/tests/fixtures/objects/interface_field_assignment.ts b/crates/submilli-engine/tests/fixtures/objects/interface_field_assignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/objects/interface_field_assignment.ts rename to crates/submilli-engine/tests/fixtures/objects/interface_field_assignment.ts diff --git a/crates/interpreter/tests/fixtures/objects/interface_property_write_dispatch.ts b/crates/submilli-engine/tests/fixtures/objects/interface_property_write_dispatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/objects/interface_property_write_dispatch.ts rename to crates/submilli-engine/tests/fixtures/objects/interface_property_write_dispatch.ts diff --git a/crates/interpreter/tests/fixtures/objects/multiline_object_literal.subm b/crates/submilli-engine/tests/fixtures/objects/multiline_object_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/multiline_object_literal.subm rename to crates/submilli-engine/tests/fixtures/objects/multiline_object_literal.subm diff --git a/crates/interpreter/tests/fixtures/objects/nullable_eq_literal.subm b/crates/submilli-engine/tests/fixtures/objects/nullable_eq_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/nullable_eq_literal.subm rename to crates/submilli-engine/tests/fixtures/objects/nullable_eq_literal.subm diff --git a/crates/interpreter/tests/fixtures/objects/nullable_field_literal.subm b/crates/submilli-engine/tests/fixtures/objects/nullable_field_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/nullable_field_literal.subm rename to crates/submilli-engine/tests/fixtures/objects/nullable_field_literal.subm diff --git a/crates/interpreter/tests/fixtures/objects/optional_field_literal.subm b/crates/submilli-engine/tests/fixtures/objects/optional_field_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/optional_field_literal.subm rename to crates/submilli-engine/tests/fixtures/objects/optional_field_literal.subm diff --git a/crates/interpreter/tests/fixtures/objects/optional_field_null_compare.subm b/crates/submilli-engine/tests/fixtures/objects/optional_field_null_compare.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/optional_field_null_compare.subm rename to crates/submilli-engine/tests/fixtures/objects/optional_field_null_compare.subm diff --git a/crates/interpreter/tests/fixtures/objects/optional_present_null.ts b/crates/submilli-engine/tests/fixtures/objects/optional_present_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/objects/optional_present_null.ts rename to crates/submilli-engine/tests/fixtures/objects/optional_present_null.ts diff --git a/crates/interpreter/tests/fixtures/objects/optional_undefined_presence.ts b/crates/submilli-engine/tests/fixtures/objects/optional_undefined_presence.ts similarity index 100% rename from crates/interpreter/tests/fixtures/objects/optional_undefined_presence.ts rename to crates/submilli-engine/tests/fixtures/objects/optional_undefined_presence.ts diff --git a/crates/interpreter/tests/fixtures/objects/property_shorthand.subm b/crates/submilli-engine/tests/fixtures/objects/property_shorthand.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/property_shorthand.subm rename to crates/submilli-engine/tests/fixtures/objects/property_shorthand.subm diff --git a/crates/interpreter/tests/fixtures/objects/quoted_property_names.subm b/crates/submilli-engine/tests/fixtures/objects/quoted_property_names.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/quoted_property_names.subm rename to crates/submilli-engine/tests/fixtures/objects/quoted_property_names.subm diff --git a/crates/interpreter/tests/fixtures/objects/reserved_keyword_property_names.subm b/crates/submilli-engine/tests/fixtures/objects/reserved_keyword_property_names.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/reserved_keyword_property_names.subm rename to crates/submilli-engine/tests/fixtures/objects/reserved_keyword_property_names.subm diff --git a/crates/interpreter/tests/fixtures/objects/union_field_access.subm b/crates/submilli-engine/tests/fixtures/objects/union_field_access.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/union_field_access.subm rename to crates/submilli-engine/tests/fixtures/objects/union_field_access.subm diff --git a/crates/interpreter/tests/fixtures/objects/widen_to_nullable_field.subm b/crates/submilli-engine/tests/fixtures/objects/widen_to_nullable_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/widen_to_nullable_field.subm rename to crates/submilli-engine/tests/fixtures/objects/widen_to_nullable_field.subm diff --git a/crates/interpreter/tests/fixtures/objects/width_sub_array.subm b/crates/submilli-engine/tests/fixtures/objects/width_sub_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/width_sub_array.subm rename to crates/submilli-engine/tests/fixtures/objects/width_sub_array.subm diff --git a/crates/interpreter/tests/fixtures/objects/width_sub_assign.subm b/crates/submilli-engine/tests/fixtures/objects/width_sub_assign.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/width_sub_assign.subm rename to crates/submilli-engine/tests/fixtures/objects/width_sub_assign.subm diff --git a/crates/interpreter/tests/fixtures/objects/width_sub_basic.subm b/crates/submilli-engine/tests/fixtures/objects/width_sub_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/width_sub_basic.subm rename to crates/submilli-engine/tests/fixtures/objects/width_sub_basic.subm diff --git a/crates/interpreter/tests/fixtures/objects/width_sub_intermediate_arg.subm b/crates/submilli-engine/tests/fixtures/objects/width_sub_intermediate_arg.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/width_sub_intermediate_arg.subm rename to crates/submilli-engine/tests/fixtures/objects/width_sub_intermediate_arg.subm diff --git a/crates/interpreter/tests/fixtures/objects/width_sub_nested.subm b/crates/submilli-engine/tests/fixtures/objects/width_sub_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/objects/width_sub_nested.subm rename to crates/submilli-engine/tests/fixtures/objects/width_sub_nested.subm diff --git a/crates/interpreter/tests/fixtures/optional_chain_near_limit.ts b/crates/submilli-engine/tests/fixtures/optional_chain_near_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chain_near_limit.ts rename to crates/submilli-engine/tests/fixtures/optional_chain_near_limit.ts diff --git a/crates/interpreter/tests/fixtures/optional_chain_non_nullable_receiver.ts b/crates/submilli-engine/tests/fixtures/optional_chain_non_nullable_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chain_non_nullable_receiver.ts rename to crates/submilli-engine/tests/fixtures/optional_chain_non_nullable_receiver.ts diff --git a/crates/interpreter/tests/fixtures/optional_chain_nullable_host_property.ts b/crates/submilli-engine/tests/fixtures/optional_chain_nullable_host_property.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chain_nullable_host_property.ts rename to crates/submilli-engine/tests/fixtures/optional_chain_nullable_host_property.ts diff --git a/crates/interpreter/tests/fixtures/optional_chain_string_key.ts b/crates/submilli-engine/tests/fixtures/optional_chain_string_key.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chain_string_key.ts rename to crates/submilli-engine/tests/fixtures/optional_chain_string_key.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/chain_then_coalesce.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/chain_then_coalesce.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/chain_then_coalesce.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/chain_then_coalesce.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/field_chain.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/field_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/field_chain.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/field_chain.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/multiple_optional.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/multiple_optional.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/multiple_optional.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/multiple_optional.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/nested_field_chain.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/nested_field_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/nested_field_chain.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/nested_field_chain.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/non_null_division.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/non_null_division.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/non_null_division.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/non_null_division.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/non_null_void_result.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/non_null_void_result.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/non_null_void_result.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/non_null_void_result.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_call.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_call.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_call.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_call_nullable_return.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_nullable_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_call_nullable_return.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_nullable_return.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_class_accessor.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_class_accessor.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_accessor.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_class_field.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_class_field.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_class_field_chain.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_class_field_chain.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field_chain.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_generic_method.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_generic_method.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_generic_method.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_generic_method.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_index.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_index.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_index.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_index.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_index_bounds.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_index_bounds.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_index_bounds.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_index_bounds.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_inherited_field.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_inherited_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_inherited_field.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_inherited_field.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_interface_accessor.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_accessor.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_interface_accessor.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_accessor.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_interface_property.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_property.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_interface_property.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_property.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_method.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_method.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_method.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_method_nullable_return.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_method_nullable_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_method_nullable_return.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_method_nullable_return.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_narrowed_step.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_narrowed_step.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_narrowed_step.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_narrowed_step.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_non_null_continuation.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_non_null_continuation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_non_null_continuation.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_non_null_continuation.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_object_prelude_member.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_object_prelude_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_object_prelude_member.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_object_prelude_member.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_primitive_receiver.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_primitive_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_primitive_receiver.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_primitive_receiver.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_redundant_primitive.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_redundant_primitive.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_redundant_primitive.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_redundant_primitive.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_union_field.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_union_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_union_field.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_union_field.ts diff --git a/crates/interpreter/tests/fixtures/optional_chaining/optional_void_method.subm b/crates/submilli-engine/tests/fixtures/optional_chaining/optional_void_method.subm similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/optional_void_method.subm rename to crates/submilli-engine/tests/fixtures/optional_chaining/optional_void_method.subm diff --git a/crates/interpreter/tests/fixtures/optional_chaining/void_result_bindings.ts b/crates/submilli-engine/tests/fixtures/optional_chaining/void_result_bindings.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_chaining/void_result_bindings.ts rename to crates/submilli-engine/tests/fixtures/optional_chaining/void_result_bindings.ts diff --git a/crates/interpreter/tests/fixtures/optional_field_written_null_serializes.ts b/crates/submilli-engine/tests/fixtures/optional_field_written_null_serializes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_field_written_null_serializes.ts rename to crates/submilli-engine/tests/fixtures/optional_field_written_null_serializes.ts diff --git a/crates/interpreter/tests/fixtures/optional_to_json_property.ts b/crates/submilli-engine/tests/fixtures/optional_to_json_property.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_to_json_property.ts rename to crates/submilli-engine/tests/fixtures/optional_to_json_property.ts diff --git a/crates/interpreter/tests/fixtures/optional_to_string_property.ts b/crates/submilli-engine/tests/fixtures/optional_to_string_property.ts similarity index 100% rename from crates/interpreter/tests/fixtures/optional_to_string_property.ts rename to crates/submilli-engine/tests/fixtures/optional_to_string_property.ts diff --git a/crates/interpreter/tests/fixtures/override_narrows_return_with_finally.ts b/crates/submilli-engine/tests/fixtures/override_narrows_return_with_finally.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_narrows_return_with_finally.ts rename to crates/submilli-engine/tests/fixtures/override_narrows_return_with_finally.ts diff --git a/crates/interpreter/tests/fixtures/override_returns_into_narrower_slot.ts b/crates/submilli-engine/tests/fixtures/override_returns_into_narrower_slot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_returns_into_narrower_slot.ts rename to crates/submilli-engine/tests/fixtures/override_returns_into_narrower_slot.ts diff --git a/crates/interpreter/tests/fixtures/override_slot_variance.ts b/crates/submilli-engine/tests/fixtures/override_slot_variance.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_slot_variance.ts rename to crates/submilli-engine/tests/fixtures/override_slot_variance.ts diff --git a/crates/interpreter/tests/fixtures/override_variance_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/override_variance_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_variance_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/override_variance_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/override_variance_cross_package/base/lib.ts b/crates/submilli-engine/tests/fixtures/override_variance_cross_package/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_variance_cross_package/base/lib.ts rename to crates/submilli-engine/tests/fixtures/override_variance_cross_package/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/override_variance_cross_package/child/lib.ts b/crates/submilli-engine/tests/fixtures/override_variance_cross_package/child/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/override_variance_cross_package/child/lib.ts rename to crates/submilli-engine/tests/fixtures/override_variance_cross_package/child/lib.ts diff --git a/crates/interpreter/tests/fixtures/override_variance_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/override_variance_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/override_variance_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/override_variance_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_binding_key/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_key/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_binding_key/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_binding_key/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_dynamic_name/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_dynamic_name/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_dynamic_name/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_dynamic_name/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_extra_tag/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_extra_tag/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_extra_tag/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_extra_tag/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_missing_tag/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_missing_tag/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_missing_tag/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_missing_tag/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_payload_key/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_payload_key/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_payload_key/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_payload_key/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/types.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/types.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/types.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/class_member_bodies/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/class_member_bodies/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/class_member_bodies/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/class_member_bodies/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/class_missing_return/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/class_missing_return/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/class_missing_return/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/class_missing_return/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/class_unreachable_code/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/class_unreachable_code/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/class_unreachable_code/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/class_unreachable_code/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/doc_callable_members/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/doc_callable_members/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/doc_callable_members/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/doc_callable_members/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/doc_consistency/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/doc_consistency/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/doc_consistency/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/doc_consistency/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest b/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest rename to crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts b/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts rename to crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/missing_return/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/missing_return/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/missing_return/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/missing_return/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/switch_fallthrough/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/switch_fallthrough/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/switch_fallthrough/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/switch_fallthrough/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/top_level_return/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/top_level_return/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/top_level_return/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/top_level_return/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/unassigned_class_field/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/unassigned_class_field/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/unassigned_class_field/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/unassigned_class_field/lib.ts diff --git a/crates/interpreter/tests/fixtures/package_rules/unreachable_code/lib.ts b/crates/submilli-engine/tests/fixtures/package_rules/unreachable_code/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/package_rules/unreachable_code/lib.ts rename to crates/submilli-engine/tests/fixtures/package_rules/unreachable_code/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_param_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/host/lib.ts b/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/host/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_param_cross_package/host/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/host/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_param_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts b/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest diff --git a/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/const_ref_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts b/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/const_ref_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts b/crates/submilli-engine/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts similarity index 100% rename from crates/interpreter/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts rename to crates/submilli-engine/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts diff --git a/crates/interpreter/tests/fixtures/parameter_literal_union_default_write.ts b/crates/submilli-engine/tests/fixtures/parameter_literal_union_default_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/parameter_literal_union_default_write.ts rename to crates/submilli-engine/tests/fixtures/parameter_literal_union_default_write.ts diff --git a/crates/interpreter/tests/fixtures/parse_int_radix_undefined.ts b/crates/submilli-engine/tests/fixtures/parse_int_radix_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/parse_int_radix_undefined.ts rename to crates/submilli-engine/tests/fixtures/parse_int_radix_undefined.ts diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_basic.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_basic.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_basic.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_bigint.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_bigint.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_bigint.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_bigint.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_captured.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_captured.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_captured.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_captured.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_field.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_field.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_field.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_global.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_global.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_global.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_global.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm diff --git a/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_index.subm b/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_index.subm similarity index 100% rename from crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_index.subm rename to crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_index.subm diff --git a/crates/interpreter/tests/fixtures/property_regressions/expect_error_in_nullable.ts b/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_in_nullable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/expect_error_in_nullable.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/expect_error_in_nullable.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts b/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/expect_error_optional_write_only.ts b/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_optional_write_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/expect_error_optional_write_only.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/expect_error_optional_write_only.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts b/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_implements.ts b/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_implements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_implements.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_implements.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/in_accessors.ts b/crates/submilli-engine/tests/fixtures/property_regressions/in_accessors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/in_accessors.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/in_accessors.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/in_erased_presence.ts b/crates/submilli-engine/tests/fixtures/property_regressions/in_erased_presence.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/in_erased_presence.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/in_erased_presence.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/in_presence.ts b/crates/submilli-engine/tests/fixtures/property_regressions/in_presence.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/in_presence.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/in_presence.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/inherited_accessors.ts b/crates/submilli-engine/tests/fixtures/property_regressions/inherited_accessors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/inherited_accessors.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/inherited_accessors.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/interface_json_surrogates.ts b/crates/submilli-engine/tests/fixtures/property_regressions/interface_json_surrogates.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/interface_json_surrogates.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/interface_json_surrogates.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/interface_postfix.ts b/crates/submilli-engine/tests/fixtures/property_regressions/interface_postfix.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/interface_postfix.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/interface_postfix.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/interface_wide_mutation.ts b/crates/submilli-engine/tests/fixtures/property_regressions/interface_wide_mutation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/interface_wide_mutation.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/interface_wide_mutation.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/postfix_package/app/main.ts b/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/postfix_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/postfix_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/postfix_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/postfix_package/packages.manifest b/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/postfix_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/property_regressions/recursive_mutation.ts b/crates/submilli-engine/tests/fixtures/property_regressions/recursive_mutation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/recursive_mutation.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/recursive_mutation.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/required_undefined_round_trip.ts b/crates/submilli-engine/tests/fixtures/property_regressions/required_undefined_round_trip.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/required_undefined_round_trip.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/required_undefined_round_trip.ts diff --git a/crates/interpreter/tests/fixtures/property_regressions/required_unknown.ts b/crates/submilli-engine/tests/fixtures/property_regressions/required_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/property_regressions/required_unknown.ts rename to crates/submilli-engine/tests/fixtures/property_regressions/required_unknown.ts diff --git a/crates/interpreter/tests/fixtures/radix_number_literals.subm b/crates/submilli-engine/tests/fixtures/radix_number_literals.subm similarity index 100% rename from crates/interpreter/tests/fixtures/radix_number_literals.subm rename to crates/submilli-engine/tests/fixtures/radix_number_literals.subm diff --git a/crates/interpreter/tests/fixtures/readonly/assignment_narrows_to_value_type.ts b/crates/submilli-engine/tests/fixtures/readonly/assignment_narrows_to_value_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/assignment_narrows_to_value_type.ts rename to crates/submilli-engine/tests/fixtures/readonly/assignment_narrows_to_value_type.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_array_writes.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_array_writes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_array_writes.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_array_writes.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_non_array.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_non_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_non_array.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_non_array.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts diff --git a/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts b/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts rename to crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts diff --git a/crates/interpreter/tests/fixtures/readonly/getonly_cannot_implement_writable.ts b/crates/submilli-engine/tests/fixtures/readonly/getonly_cannot_implement_writable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/getonly_cannot_implement_writable.ts rename to crates/submilli-engine/tests/fixtures/readonly/getonly_cannot_implement_writable.ts diff --git a/crates/interpreter/tests/fixtures/readonly/inline_object_runtime.ts b/crates/submilli-engine/tests/fixtures/readonly/inline_object_runtime.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/inline_object_runtime.ts rename to crates/submilli-engine/tests/fixtures/readonly/inline_object_runtime.ts diff --git a/crates/interpreter/tests/fixtures/readonly/interface_property_write_rejected.ts b/crates/submilli-engine/tests/fixtures/readonly/interface_property_write_rejected.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/interface_property_write_rejected.ts rename to crates/submilli-engine/tests/fixtures/readonly/interface_property_write_rejected.ts diff --git a/crates/interpreter/tests/fixtures/readonly/object_type_property_write_rejected.ts b/crates/submilli-engine/tests/fixtures/readonly/object_type_property_write_rejected.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/object_type_property_write_rejected.ts rename to crates/submilli-engine/tests/fixtures/readonly/object_type_property_write_rejected.ts diff --git a/crates/interpreter/tests/fixtures/readonly/readonly_array_reads.ts b/crates/submilli-engine/tests/fixtures/readonly/readonly_array_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/readonly_array_reads.ts rename to crates/submilli-engine/tests/fixtures/readonly/readonly_array_reads.ts diff --git a/crates/interpreter/tests/fixtures/readonly/writable_property_write_ok.ts b/crates/submilli-engine/tests/fixtures/readonly/writable_property_write_ok.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly/writable_property_write_ok.ts rename to crates/submilli-engine/tests/fixtures/readonly/writable_property_write_ok.ts diff --git a/crates/interpreter/tests/fixtures/readonly_cast_qualifiers.ts b/crates/submilli-engine/tests/fixtures/readonly_cast_qualifiers.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly_cast_qualifiers.ts rename to crates/submilli-engine/tests/fixtures/readonly_cast_qualifiers.ts diff --git a/crates/interpreter/tests/fixtures/readonly_rest_parameter.ts b/crates/submilli-engine/tests/fixtures/readonly_rest_parameter.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly_rest_parameter.ts rename to crates/submilli-engine/tests/fixtures/readonly_rest_parameter.ts diff --git a/crates/interpreter/tests/fixtures/readonly_rest_parameter_write.ts b/crates/submilli-engine/tests/fixtures/readonly_rest_parameter_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/readonly_rest_parameter_write.ts rename to crates/submilli-engine/tests/fixtures/readonly_rest_parameter_write.ts diff --git a/crates/interpreter/tests/fixtures/readonly_string_length.subm b/crates/submilli-engine/tests/fixtures/readonly_string_length.subm similarity index 100% rename from crates/interpreter/tests/fixtures/readonly_string_length.subm rename to crates/submilli-engine/tests/fixtures/readonly_string_length.subm diff --git a/crates/interpreter/tests/fixtures/records/cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/records/cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/records/cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/records/cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/records/cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/records/cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/records/cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/records/cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/records/cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/records/cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/records/indexed_growth_and_equality.ts b/crates/submilli-engine/tests/fixtures/records/indexed_growth_and_equality.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/indexed_growth_and_equality.ts rename to crates/submilli-engine/tests/fixtures/records/indexed_growth_and_equality.ts diff --git a/crates/interpreter/tests/fixtures/records/optional_dynamic_presence.ts b/crates/submilli-engine/tests/fixtures/records/optional_dynamic_presence.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/optional_dynamic_presence.ts rename to crates/submilli-engine/tests/fixtures/records/optional_dynamic_presence.ts diff --git a/crates/interpreter/tests/fixtures/records/record_accessors.ts b/crates/submilli-engine/tests/fixtures/records/record_accessors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_accessors.ts rename to crates/submilli-engine/tests/fixtures/records/record_accessors.ts diff --git a/crates/interpreter/tests/fixtures/records/record_bad_computed_spread.ts b/crates/submilli-engine/tests/fixtures/records/record_bad_computed_spread.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_bad_computed_spread.ts rename to crates/submilli-engine/tests/fixtures/records/record_bad_computed_spread.ts diff --git a/crates/interpreter/tests/fixtures/records/record_basic.ts b/crates/submilli-engine/tests/fixtures/records/record_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_basic.ts rename to crates/submilli-engine/tests/fixtures/records/record_basic.ts diff --git a/crates/interpreter/tests/fixtures/records/record_checked_reads.ts b/crates/submilli-engine/tests/fixtures/records/record_checked_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_checked_reads.ts rename to crates/submilli-engine/tests/fixtures/records/record_checked_reads.ts diff --git a/crates/interpreter/tests/fixtures/records/record_class_guards.ts b/crates/submilli-engine/tests/fixtures/records/record_class_guards.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_class_guards.ts rename to crates/submilli-engine/tests/fixtures/records/record_class_guards.ts diff --git a/crates/interpreter/tests/fixtures/records/record_conditional_spread.ts b/crates/submilli-engine/tests/fixtures/records/record_conditional_spread.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_conditional_spread.ts rename to crates/submilli-engine/tests/fixtures/records/record_conditional_spread.ts diff --git a/crates/interpreter/tests/fixtures/records/record_errors.ts b/crates/submilli-engine/tests/fixtures/records/record_errors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_errors.ts rename to crates/submilli-engine/tests/fixtures/records/record_errors.ts diff --git a/crates/interpreter/tests/fixtures/records/record_evaluation.ts b/crates/submilli-engine/tests/fixtures/records/record_evaluation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_evaluation.ts rename to crates/submilli-engine/tests/fixtures/records/record_evaluation.ts diff --git a/crates/interpreter/tests/fixtures/records/record_features.ts b/crates/submilli-engine/tests/fixtures/records/record_features.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_features.ts rename to crates/submilli-engine/tests/fixtures/records/record_features.ts diff --git a/crates/interpreter/tests/fixtures/records/record_forward_index.ts b/crates/submilli-engine/tests/fixtures/records/record_forward_index.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_forward_index.ts rename to crates/submilli-engine/tests/fixtures/records/record_forward_index.ts diff --git a/crates/interpreter/tests/fixtures/records/record_function_receiver.ts b/crates/submilli-engine/tests/fixtures/records/record_function_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_function_receiver.ts rename to crates/submilli-engine/tests/fixtures/records/record_function_receiver.ts diff --git a/crates/interpreter/tests/fixtures/records/record_generic_contract_errors.ts b/crates/submilli-engine/tests/fixtures/records/record_generic_contract_errors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_generic_contract_errors.ts rename to crates/submilli-engine/tests/fixtures/records/record_generic_contract_errors.ts diff --git a/crates/interpreter/tests/fixtures/records/record_generic_method_errors.ts b/crates/submilli-engine/tests/fixtures/records/record_generic_method_errors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_generic_method_errors.ts rename to crates/submilli-engine/tests/fixtures/records/record_generic_method_errors.ts diff --git a/crates/interpreter/tests/fixtures/records/record_generic_methods.ts b/crates/submilli-engine/tests/fixtures/records/record_generic_methods.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_generic_methods.ts rename to crates/submilli-engine/tests/fixtures/records/record_generic_methods.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_composition.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_composition.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_composition.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_composition.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_composition_errors.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_composition_errors.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_composition_errors.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_composition_errors.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_conflicts.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_conflicts.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_conflicts.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_conflicts.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_forward_alias.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_forward_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_forward_alias.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_forward_alias.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_members.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_members.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_members.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_members.ts diff --git a/crates/interpreter/tests/fixtures/records/record_inherit_narrow.ts b/crates/submilli-engine/tests/fixtures/records/record_inherit_narrow.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_inherit_narrow.ts rename to crates/submilli-engine/tests/fixtures/records/record_inherit_narrow.ts diff --git a/crates/interpreter/tests/fixtures/records/record_interface_reads.ts b/crates/submilli-engine/tests/fixtures/records/record_interface_reads.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_interface_reads.ts rename to crates/submilli-engine/tests/fixtures/records/record_interface_reads.ts diff --git a/crates/interpreter/tests/fixtures/records/record_literal_writes.ts b/crates/submilli-engine/tests/fixtures/records/record_literal_writes.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_literal_writes.ts rename to crates/submilli-engine/tests/fixtures/records/record_literal_writes.ts diff --git a/crates/interpreter/tests/fixtures/records/record_postfix_checked.ts b/crates/submilli-engine/tests/fixtures/records/record_postfix_checked.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_postfix_checked.ts rename to crates/submilli-engine/tests/fixtures/records/record_postfix_checked.ts diff --git a/crates/interpreter/tests/fixtures/records/record_recursive.ts b/crates/submilli-engine/tests/fixtures/records/record_recursive.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_recursive.ts rename to crates/submilli-engine/tests/fixtures/records/record_recursive.ts diff --git a/crates/interpreter/tests/fixtures/records/record_recursive_interface_error.ts b/crates/submilli-engine/tests/fixtures/records/record_recursive_interface_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_recursive_interface_error.ts rename to crates/submilli-engine/tests/fixtures/records/record_recursive_interface_error.ts diff --git a/crates/interpreter/tests/fixtures/records/record_structural_write.ts b/crates/submilli-engine/tests/fixtures/records/record_structural_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_structural_write.ts rename to crates/submilli-engine/tests/fixtures/records/record_structural_write.ts diff --git a/crates/interpreter/tests/fixtures/records/record_unions.ts b/crates/submilli-engine/tests/fixtures/records/record_unions.ts similarity index 100% rename from crates/interpreter/tests/fixtures/records/record_unions.ts rename to crates/submilli-engine/tests/fixtures/records/record_unions.ts diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_linked_list.subm b/crates/submilli-engine/tests/fixtures/recursive-types/alias_linked_list.subm similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_linked_list.subm rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_linked_list.subm diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts b/crates/submilli-engine/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_through_array.ts b/crates/submilli-engine/tests/fixtures/recursive-types/alias_through_array.ts similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_through_array.ts rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_through_array.ts diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_through_generic_call.ts b/crates/submilli-engine/tests/fixtures/recursive-types/alias_through_generic_call.ts similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_through_generic_call.ts rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_through_generic_call.ts diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_tree.subm b/crates/submilli-engine/tests/fixtures/recursive-types/alias_tree.subm similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_tree.subm rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_tree.subm diff --git a/crates/interpreter/tests/fixtures/recursive-types/alias_union_json.subm b/crates/submilli-engine/tests/fixtures/recursive-types/alias_union_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/alias_union_json.subm rename to crates/submilli-engine/tests/fixtures/recursive-types/alias_union_json.subm diff --git a/crates/interpreter/tests/fixtures/recursive-types/interface_resolution.subm b/crates/submilli-engine/tests/fixtures/recursive-types/interface_resolution.subm similarity index 100% rename from crates/interpreter/tests/fixtures/recursive-types/interface_resolution.subm rename to crates/submilli-engine/tests/fixtures/recursive-types/interface_resolution.subm diff --git a/crates/interpreter/tests/fixtures/regex_exec_basic.subm b/crates/submilli-engine/tests/fixtures/regex_exec_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_exec_basic.subm rename to crates/submilli-engine/tests/fixtures/regex_exec_basic.subm diff --git a/crates/interpreter/tests/fixtures/regex_flags_all.subm b/crates/submilli-engine/tests/fixtures/regex_flags_all.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_flags_all.subm rename to crates/submilli-engine/tests/fixtures/regex_flags_all.subm diff --git a/crates/interpreter/tests/fixtures/regex_input_cache.ts b/crates/submilli-engine/tests/fixtures/regex_input_cache.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regex_input_cache.ts rename to crates/submilli-engine/tests/fixtures/regex_input_cache.ts diff --git a/crates/interpreter/tests/fixtures/regex_lastindex_non_global.subm b/crates/submilli-engine/tests/fixtures/regex_lastindex_non_global.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_lastindex_non_global.subm rename to crates/submilli-engine/tests/fixtures/regex_lastindex_non_global.subm diff --git a/crates/interpreter/tests/fixtures/regex_lastindex_sticky.subm b/crates/submilli-engine/tests/fixtures/regex_lastindex_sticky.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_lastindex_sticky.subm rename to crates/submilli-engine/tests/fixtures/regex_lastindex_sticky.subm diff --git a/crates/interpreter/tests/fixtures/regex_literal_basic.subm b/crates/submilli-engine/tests/fixtures/regex_literal_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_literal_basic.subm rename to crates/submilli-engine/tests/fixtures/regex_literal_basic.subm diff --git a/crates/interpreter/tests/fixtures/regex_named_captures.subm b/crates/submilli-engine/tests/fixtures/regex_named_captures.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_named_captures.subm rename to crates/submilli-engine/tests/fixtures/regex_named_captures.subm diff --git a/crates/interpreter/tests/fixtures/regex_named_captures_unmatched.ts b/crates/submilli-engine/tests/fixtures/regex_named_captures_unmatched.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regex_named_captures_unmatched.ts rename to crates/submilli-engine/tests/fixtures/regex_named_captures_unmatched.ts diff --git a/crates/interpreter/tests/fixtures/regex_non_ascii_literal.ts b/crates/submilli-engine/tests/fixtures/regex_non_ascii_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regex_non_ascii_literal.ts rename to crates/submilli-engine/tests/fixtures/regex_non_ascii_literal.ts diff --git a/crates/interpreter/tests/fixtures/regex_numbered_captures.subm b/crates/submilli-engine/tests/fixtures/regex_numbered_captures.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_numbered_captures.subm rename to crates/submilli-engine/tests/fixtures/regex_numbered_captures.subm diff --git a/crates/interpreter/tests/fixtures/regex_per_site_lastindex.subm b/crates/submilli-engine/tests/fixtures/regex_per_site_lastindex.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_per_site_lastindex.subm rename to crates/submilli-engine/tests/fixtures/regex_per_site_lastindex.subm diff --git a/crates/interpreter/tests/fixtures/regex_property_reads.subm b/crates/submilli-engine/tests/fixtures/regex_property_reads.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_property_reads.subm rename to crates/submilli-engine/tests/fixtures/regex_property_reads.subm diff --git a/crates/interpreter/tests/fixtures/regex_shared_input.ts b/crates/submilli-engine/tests/fixtures/regex_shared_input.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regex_shared_input.ts rename to crates/submilli-engine/tests/fixtures/regex_shared_input.ts diff --git a/crates/interpreter/tests/fixtures/regex_test_basic.subm b/crates/submilli-engine/tests/fixtures/regex_test_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_test_basic.subm rename to crates/submilli-engine/tests/fixtures/regex_test_basic.subm diff --git a/crates/interpreter/tests/fixtures/regex_test_lastindex_global.subm b/crates/submilli-engine/tests/fixtures/regex_test_lastindex_global.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_test_lastindex_global.subm rename to crates/submilli-engine/tests/fixtures/regex_test_lastindex_global.subm diff --git a/crates/interpreter/tests/fixtures/regex_to_string.subm b/crates/submilli-engine/tests/fixtures/regex_to_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regex_to_string.subm rename to crates/submilli-engine/tests/fixtures/regex_to_string.subm diff --git a/crates/interpreter/tests/fixtures/regex_utf16_offsets.ts b/crates/submilli-engine/tests/fixtures/regex_utf16_offsets.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regex_utf16_offsets.ts rename to crates/submilli-engine/tests/fixtures/regex_utf16_offsets.ts diff --git a/crates/interpreter/tests/fixtures/regexp_invalid_flags_type.ts b/crates/submilli-engine/tests/fixtures/regexp_invalid_flags_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_invalid_flags_type.ts rename to crates/submilli-engine/tests/fixtures/regexp_invalid_flags_type.ts diff --git a/crates/interpreter/tests/fixtures/regexp_match_keeps_lone_surrogates.subm b/crates/submilli-engine/tests/fixtures/regexp_match_keeps_lone_surrogates.subm similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_match_keeps_lone_surrogates.subm rename to crates/submilli-engine/tests/fixtures/regexp_match_keeps_lone_surrogates.subm diff --git a/crates/interpreter/tests/fixtures/regexp_missing_source.ts b/crates/submilli-engine/tests/fixtures/regexp_missing_source.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_missing_source.ts rename to crates/submilli-engine/tests/fixtures/regexp_missing_source.ts diff --git a/crates/interpreter/tests/fixtures/regexp_optional_flags.ts b/crates/submilli-engine/tests/fixtures/regexp_optional_flags.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_optional_flags.ts rename to crates/submilli-engine/tests/fixtures/regexp_optional_flags.ts diff --git a/crates/interpreter/tests/fixtures/regexp_replace_split_match_js.ts b/crates/submilli-engine/tests/fixtures/regexp_replace_split_match_js.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_replace_split_match_js.ts rename to crates/submilli-engine/tests/fixtures/regexp_replace_split_match_js.ts diff --git a/crates/interpreter/tests/fixtures/regexp_shorthand_classes_match_js.ts b/crates/submilli-engine/tests/fixtures/regexp_shorthand_classes_match_js.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_shorthand_classes_match_js.ts rename to crates/submilli-engine/tests/fixtures/regexp_shorthand_classes_match_js.ts diff --git a/crates/interpreter/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts b/crates/submilli-engine/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts rename to crates/submilli-engine/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts diff --git a/crates/interpreter/tests/fixtures/rejected_field_write_rhs_hint.ts b/crates/submilli-engine/tests/fixtures/rejected_field_write_rhs_hint.ts similarity index 100% rename from crates/interpreter/tests/fixtures/rejected_field_write_rhs_hint.ts rename to crates/submilli-engine/tests/fixtures/rejected_field_write_rhs_hint.ts diff --git a/crates/interpreter/tests/fixtures/rest_callback_for_fixed_arity.ts b/crates/submilli-engine/tests/fixtures/rest_callback_for_fixed_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/rest_callback_for_fixed_arity.ts rename to crates/submilli-engine/tests/fixtures/rest_callback_for_fixed_arity.ts diff --git a/crates/interpreter/tests/fixtures/rest_param_arrow.subm b/crates/submilli-engine/tests/fixtures/rest_param_arrow.subm similarity index 100% rename from crates/interpreter/tests/fixtures/rest_param_arrow.subm rename to crates/submilli-engine/tests/fixtures/rest_param_arrow.subm diff --git a/crates/interpreter/tests/fixtures/rest_param_basic.subm b/crates/submilli-engine/tests/fixtures/rest_param_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/rest_param_basic.subm rename to crates/submilli-engine/tests/fixtures/rest_param_basic.subm diff --git a/crates/interpreter/tests/fixtures/rest_param_generic.subm b/crates/submilli-engine/tests/fixtures/rest_param_generic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/rest_param_generic.subm rename to crates/submilli-engine/tests/fixtures/rest_param_generic.subm diff --git a/crates/interpreter/tests/fixtures/rest_param_mixed.subm b/crates/submilli-engine/tests/fixtures/rest_param_mixed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/rest_param_mixed.subm rename to crates/submilli-engine/tests/fixtures/rest_param_mixed.subm diff --git a/crates/interpreter/tests/fixtures/return_paths_void_union_and_getters.ts b/crates/submilli-engine/tests/fixtures/return_paths_void_union_and_getters.ts similarity index 100% rename from crates/interpreter/tests/fixtures/return_paths_void_union_and_getters.ts rename to crates/submilli-engine/tests/fixtures/return_paths_void_union_and_getters.ts diff --git a/crates/interpreter/tests/fixtures/secrets_main_denied.ts b/crates/submilli-engine/tests/fixtures/secrets_main_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/secrets_main_denied.ts rename to crates/submilli-engine/tests/fixtures/secrets_main_denied.ts diff --git a/crates/interpreter/tests/fixtures/session_basic.ts b/crates/submilli-engine/tests/fixtures/session_basic.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_basic.ts rename to crates/submilli-engine/tests/fixtures/session_basic.ts diff --git a/crates/interpreter/tests/fixtures/session_cursor_length_budget.ts b/crates/submilli-engine/tests/fixtures/session_cursor_length_budget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_cursor_length_budget.ts rename to crates/submilli-engine/tests/fixtures/session_cursor_length_budget.ts diff --git a/crates/interpreter/tests/fixtures/session_denied.ts b/crates/submilli-engine/tests/fixtures/session_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_denied.ts rename to crates/submilli-engine/tests/fixtures/session_denied.ts diff --git a/crates/interpreter/tests/fixtures/session_get_erased.ts b/crates/submilli-engine/tests/fixtures/session_get_erased.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_get_erased.ts rename to crates/submilli-engine/tests/fixtures/session_get_erased.ts diff --git a/crates/interpreter/tests/fixtures/session_get_mismatch.ts b/crates/submilli-engine/tests/fixtures/session_get_mismatch.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_get_mismatch.ts rename to crates/submilli-engine/tests/fixtures/session_get_mismatch.ts diff --git a/crates/interpreter/tests/fixtures/session_get_unknown.ts b/crates/submilli-engine/tests/fixtures/session_get_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_get_unknown.ts rename to crates/submilli-engine/tests/fixtures/session_get_unknown.ts diff --git a/crates/interpreter/tests/fixtures/session_list.ts b/crates/submilli-engine/tests/fixtures/session_list.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_list.ts rename to crates/submilli-engine/tests/fixtures/session_list.ts diff --git a/crates/interpreter/tests/fixtures/session_list_cursor_is_sealed.ts b/crates/submilli-engine/tests/fixtures/session_list_cursor_is_sealed.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_list_cursor_is_sealed.ts rename to crates/submilli-engine/tests/fixtures/session_list_cursor_is_sealed.ts diff --git a/crates/interpreter/tests/fixtures/session_list_filtered.ts b/crates/submilli-engine/tests/fixtures/session_list_filtered.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_list_filtered.ts rename to crates/submilli-engine/tests/fixtures/session_list_filtered.ts diff --git a/crates/interpreter/tests/fixtures/session_remove_denied.ts b/crates/submilli-engine/tests/fixtures/session_remove_denied.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_remove_denied.ts rename to crates/submilli-engine/tests/fixtures/session_remove_denied.ts diff --git a/crates/interpreter/tests/fixtures/session_surrogate_fidelity.ts b/crates/submilli-engine/tests/fixtures/session_surrogate_fidelity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_surrogate_fidelity.ts rename to crates/submilli-engine/tests/fixtures/session_surrogate_fidelity.ts diff --git a/crates/interpreter/tests/fixtures/session_typed_get.ts b/crates/submilli-engine/tests/fixtures/session_typed_get.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_typed_get.ts rename to crates/submilli-engine/tests/fixtures/session_typed_get.ts diff --git a/crates/interpreter/tests/fixtures/session_unsupported_value.ts b/crates/submilli-engine/tests/fixtures/session_unsupported_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/session_unsupported_value.ts rename to crates/submilli-engine/tests/fixtures/session_unsupported_value.ts diff --git a/crates/interpreter/tests/fixtures/set_algebra.subm b/crates/submilli-engine/tests/fixtures/set_algebra.subm similarity index 100% rename from crates/interpreter/tests/fixtures/set_algebra.subm rename to crates/submilli-engine/tests/fixtures/set_algebra.subm diff --git a/crates/interpreter/tests/fixtures/set_iteration_parity.subm b/crates/submilli-engine/tests/fixtures/set_iteration_parity.subm similarity index 100% rename from crates/interpreter/tests/fixtures/set_iteration_parity.subm rename to crates/submilli-engine/tests/fixtures/set_iteration_parity.subm diff --git a/crates/interpreter/tests/fixtures/set_relations.subm b/crates/submilli-engine/tests/fixtures/set_relations.subm similarity index 100% rename from crates/interpreter/tests/fixtures/set_relations.subm rename to crates/submilli-engine/tests/fixtures/set_relations.subm diff --git a/crates/interpreter/tests/fixtures/shared_serializer_buffer.ts b/crates/submilli-engine/tests/fixtures/shared_serializer_buffer.ts similarity index 100% rename from crates/interpreter/tests/fixtures/shared_serializer_buffer.ts rename to crates/submilli-engine/tests/fixtures/shared_serializer_buffer.ts diff --git a/crates/interpreter/tests/fixtures/spread/array_basic.subm b/crates/submilli-engine/tests/fixtures/spread/array_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/array_basic.subm rename to crates/submilli-engine/tests/fixtures/spread/array_basic.subm diff --git a/crates/interpreter/tests/fixtures/spread/array_empty_source.subm b/crates/submilli-engine/tests/fixtures/spread/array_empty_source.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/array_empty_source.subm rename to crates/submilli-engine/tests/fixtures/spread/array_empty_source.subm diff --git a/crates/interpreter/tests/fixtures/spread/array_only_spreads.subm b/crates/submilli-engine/tests/fixtures/spread/array_only_spreads.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/array_only_spreads.subm rename to crates/submilli-engine/tests/fixtures/spread/array_only_spreads.subm diff --git a/crates/interpreter/tests/fixtures/spread/err_array_spread_element_mismatch.subm b/crates/submilli-engine/tests/fixtures/spread/err_array_spread_element_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/err_array_spread_element_mismatch.subm rename to crates/submilli-engine/tests/fixtures/spread/err_array_spread_element_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/spread/err_array_spread_non_array.subm b/crates/submilli-engine/tests/fixtures/spread/err_array_spread_non_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/err_array_spread_non_array.subm rename to crates/submilli-engine/tests/fixtures/spread/err_array_spread_non_array.subm diff --git a/crates/interpreter/tests/fixtures/spread/err_object_spread_interface.subm b/crates/submilli-engine/tests/fixtures/spread/err_object_spread_interface.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/err_object_spread_interface.subm rename to crates/submilli-engine/tests/fixtures/spread/err_object_spread_interface.subm diff --git a/crates/interpreter/tests/fixtures/spread/err_object_spread_non_object.subm b/crates/submilli-engine/tests/fixtures/spread/err_object_spread_non_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/err_object_spread_non_object.subm rename to crates/submilli-engine/tests/fixtures/spread/err_object_spread_non_object.subm diff --git a/crates/interpreter/tests/fixtures/spread/object_basic.subm b/crates/submilli-engine/tests/fixtures/spread/object_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/object_basic.subm rename to crates/submilli-engine/tests/fixtures/spread/object_basic.subm diff --git a/crates/interpreter/tests/fixtures/spread/object_multiple_spreads.subm b/crates/submilli-engine/tests/fixtures/spread/object_multiple_spreads.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/object_multiple_spreads.subm rename to crates/submilli-engine/tests/fixtures/spread/object_multiple_spreads.subm diff --git a/crates/interpreter/tests/fixtures/spread/object_override_literal_after.subm b/crates/submilli-engine/tests/fixtures/spread/object_override_literal_after.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/object_override_literal_after.subm rename to crates/submilli-engine/tests/fixtures/spread/object_override_literal_after.subm diff --git a/crates/interpreter/tests/fixtures/spread/object_override_literal_before.subm b/crates/submilli-engine/tests/fixtures/spread/object_override_literal_before.subm similarity index 100% rename from crates/interpreter/tests/fixtures/spread/object_override_literal_before.subm rename to crates/submilli-engine/tests/fixtures/spread/object_override_literal_before.subm diff --git a/crates/interpreter/tests/fixtures/spread_index_signature_union.ts b/crates/submilli-engine/tests/fixtures/spread_index_signature_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/spread_index_signature_union.ts rename to crates/submilli-engine/tests/fixtures/spread_index_signature_union.ts diff --git a/crates/interpreter/tests/fixtures/spread_into_discriminated_union.ts b/crates/submilli-engine/tests/fixtures/spread_into_discriminated_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/spread_into_discriminated_union.ts rename to crates/submilli-engine/tests/fixtures/spread_into_discriminated_union.ts diff --git a/crates/interpreter/tests/fixtures/spread_of_conditional_or_union.ts b/crates/submilli-engine/tests/fixtures/spread_of_conditional_or_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/spread_of_conditional_or_union.ts rename to crates/submilli-engine/tests/fixtures/spread_of_conditional_or_union.ts diff --git a/crates/interpreter/tests/fixtures/spread_of_falsy_value.ts b/crates/submilli-engine/tests/fixtures/spread_of_falsy_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/spread_of_falsy_value.ts rename to crates/submilli-engine/tests/fixtures/spread_of_falsy_value.ts diff --git a/crates/interpreter/tests/fixtures/spread_union_assigned_back.ts b/crates/submilli-engine/tests/fixtures/spread_union_assigned_back.ts similarity index 100% rename from crates/interpreter/tests/fixtures/spread_union_assigned_back.ts rename to crates/submilli-engine/tests/fixtures/spread_union_assigned_back.ts diff --git a/crates/interpreter/tests/fixtures/static_binding_as_value.ts b/crates/submilli-engine/tests/fixtures/static_binding_as_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/static_binding_as_value.ts rename to crates/submilli-engine/tests/fixtures/static_binding_as_value.ts diff --git a/crates/interpreter/tests/fixtures/strict_mode_reserved_words_as_properties.ts b/crates/submilli-engine/tests/fixtures/strict_mode_reserved_words_as_properties.ts similarity index 100% rename from crates/interpreter/tests/fixtures/strict_mode_reserved_words_as_properties.ts rename to crates/submilli-engine/tests/fixtures/strict_mode_reserved_words_as_properties.ts diff --git a/crates/interpreter/tests/fixtures/string_admitted_builders.ts b/crates/submilli-engine/tests/fixtures/string_admitted_builders.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_admitted_builders.ts rename to crates/submilli-engine/tests/fixtures/string_admitted_builders.ts diff --git a/crates/interpreter/tests/fixtures/string_at_nullable.ts b/crates/submilli-engine/tests/fixtures/string_at_nullable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_at_nullable.ts rename to crates/submilli-engine/tests/fixtures/string_at_nullable.ts diff --git a/crates/interpreter/tests/fixtures/string_case.subm b/crates/submilli-engine/tests/fixtures/string_case.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_case.subm rename to crates/submilli-engine/tests/fixtures/string_case.subm diff --git a/crates/interpreter/tests/fixtures/string_char_at.subm b/crates/submilli-engine/tests/fixtures/string_char_at.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_char_at.subm rename to crates/submilli-engine/tests/fixtures/string_char_at.subm diff --git a/crates/interpreter/tests/fixtures/string_code_point_at_out_of_range.ts b/crates/submilli-engine/tests/fixtures/string_code_point_at_out_of_range.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_code_point_at_out_of_range.ts rename to crates/submilli-engine/tests/fixtures/string_code_point_at_out_of_range.ts diff --git a/crates/interpreter/tests/fixtures/string_concat.subm b/crates/submilli-engine/tests/fixtures/string_concat.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_concat.subm rename to crates/submilli-engine/tests/fixtures/string_concat.subm diff --git a/crates/interpreter/tests/fixtures/string_for_of.subm b/crates/submilli-engine/tests/fixtures/string_for_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_for_of.subm rename to crates/submilli-engine/tests/fixtures/string_for_of.subm diff --git a/crates/interpreter/tests/fixtures/string_from_char_code.subm b/crates/submilli-engine/tests/fixtures/string_from_char_code.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_from_char_code.subm rename to crates/submilli-engine/tests/fixtures/string_from_char_code.subm diff --git a/crates/interpreter/tests/fixtures/string_from_char_code_wraps.ts b/crates/submilli-engine/tests/fixtures/string_from_char_code_wraps.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_from_char_code_wraps.ts rename to crates/submilli-engine/tests/fixtures/string_from_char_code_wraps.ts diff --git a/crates/interpreter/tests/fixtures/string_from_code_point.subm b/crates/submilli-engine/tests/fixtures/string_from_code_point.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_from_code_point.subm rename to crates/submilli-engine/tests/fixtures/string_from_code_point.subm diff --git a/crates/interpreter/tests/fixtures/string_index_of.subm b/crates/submilli-engine/tests/fixtures/string_index_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_index_of.subm rename to crates/submilli-engine/tests/fixtures/string_index_of.subm diff --git a/crates/interpreter/tests/fixtures/string_key_member_access.ts b/crates/submilli-engine/tests/fixtures/string_key_member_access.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_key_member_access.ts rename to crates/submilli-engine/tests/fixtures/string_key_member_access.ts diff --git a/crates/interpreter/tests/fixtures/string_length.subm b/crates/submilli-engine/tests/fixtures/string_length.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_length.subm rename to crates/submilli-engine/tests/fixtures/string_length.subm diff --git a/crates/interpreter/tests/fixtures/string_linear_search.ts b/crates/submilli-engine/tests/fixtures/string_linear_search.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_linear_search.ts rename to crates/submilli-engine/tests/fixtures/string_linear_search.ts diff --git a/crates/interpreter/tests/fixtures/string_literal_lone_surrogates.ts b/crates/submilli-engine/tests/fixtures/string_literal_lone_surrogates.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_literal_lone_surrogates.ts rename to crates/submilli-engine/tests/fixtures/string_literal_lone_surrogates.ts diff --git a/crates/interpreter/tests/fixtures/string_match_all.subm b/crates/submilli-engine/tests/fixtures/string_match_all.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_match_all.subm rename to crates/submilli-engine/tests/fixtures/string_match_all.subm diff --git a/crates/interpreter/tests/fixtures/string_match_and_search.subm b/crates/submilli-engine/tests/fixtures/string_match_and_search.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_match_and_search.subm rename to crates/submilli-engine/tests/fixtures/string_match_and_search.subm diff --git a/crates/interpreter/tests/fixtures/string_multiline_raw_newline.ts b/crates/submilli-engine/tests/fixtures/string_multiline_raw_newline.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_multiline_raw_newline.ts rename to crates/submilli-engine/tests/fixtures/string_multiline_raw_newline.ts diff --git a/crates/interpreter/tests/fixtures/string_normalize.subm b/crates/submilli-engine/tests/fixtures/string_normalize.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_normalize.subm rename to crates/submilli-engine/tests/fixtures/string_normalize.subm diff --git a/crates/interpreter/tests/fixtures/string_of_null.ts b/crates/submilli-engine/tests/fixtures/string_of_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_of_null.ts rename to crates/submilli-engine/tests/fixtures/string_of_null.ts diff --git a/crates/interpreter/tests/fixtures/string_ops_keep_lone_surrogates.ts b/crates/submilli-engine/tests/fixtures/string_ops_keep_lone_surrogates.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_ops_keep_lone_surrogates.ts rename to crates/submilli-engine/tests/fixtures/string_ops_keep_lone_surrogates.ts diff --git a/crates/interpreter/tests/fixtures/string_or_array_union_methods.ts b/crates/submilli-engine/tests/fixtures/string_or_array_union_methods.ts similarity index 100% rename from crates/interpreter/tests/fixtures/string_or_array_union_methods.ts rename to crates/submilli-engine/tests/fixtures/string_or_array_union_methods.ts diff --git a/crates/interpreter/tests/fixtures/string_ordering.subm b/crates/submilli-engine/tests/fixtures/string_ordering.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_ordering.subm rename to crates/submilli-engine/tests/fixtures/string_ordering.subm diff --git a/crates/interpreter/tests/fixtures/string_pad.subm b/crates/submilli-engine/tests/fixtures/string_pad.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_pad.subm rename to crates/submilli-engine/tests/fixtures/string_pad.subm diff --git a/crates/interpreter/tests/fixtures/string_repeat.subm b/crates/submilli-engine/tests/fixtures/string_repeat.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_repeat.subm rename to crates/submilli-engine/tests/fixtures/string_repeat.subm diff --git a/crates/interpreter/tests/fixtures/string_repeat_negative.subm b/crates/submilli-engine/tests/fixtures/string_repeat_negative.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_repeat_negative.subm rename to crates/submilli-engine/tests/fixtures/string_repeat_negative.subm diff --git a/crates/interpreter/tests/fixtures/string_replace.subm b/crates/submilli-engine/tests/fixtures/string_replace.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_replace.subm rename to crates/submilli-engine/tests/fixtures/string_replace.subm diff --git a/crates/interpreter/tests/fixtures/string_replace_all.subm b/crates/submilli-engine/tests/fixtures/string_replace_all.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_replace_all.subm rename to crates/submilli-engine/tests/fixtures/string_replace_all.subm diff --git a/crates/interpreter/tests/fixtures/string_slice.subm b/crates/submilli-engine/tests/fixtures/string_slice.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_slice.subm rename to crates/submilli-engine/tests/fixtures/string_slice.subm diff --git a/crates/interpreter/tests/fixtures/string_split.subm b/crates/submilli-engine/tests/fixtures/string_split.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_split.subm rename to crates/submilli-engine/tests/fixtures/string_split.subm diff --git a/crates/interpreter/tests/fixtures/string_starts_with.subm b/crates/submilli-engine/tests/fixtures/string_starts_with.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_starts_with.subm rename to crates/submilli-engine/tests/fixtures/string_starts_with.subm diff --git a/crates/interpreter/tests/fixtures/string_trim.subm b/crates/submilli-engine/tests/fixtures/string_trim.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_trim.subm rename to crates/submilli-engine/tests/fixtures/string_trim.subm diff --git a/crates/interpreter/tests/fixtures/string_well_formed.subm b/crates/submilli-engine/tests/fixtures/string_well_formed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/string_well_formed.subm rename to crates/submilli-engine/tests/fixtures/string_well_formed.subm diff --git a/crates/interpreter/tests/fixtures/structural_equals_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/structural_equals_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/structural_equals_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/structural_equals_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/structural_equals_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/structural_equals_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/structural_equals_cross_package/points/lib.ts b/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/points/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/structural_equals_cross_package/points/lib.ts rename to crates/submilli-engine/tests/fixtures/structural_equals_cross_package/points/lib.ts diff --git a/crates/interpreter/tests/fixtures/structural_equals_shape_guard.ts b/crates/submilli-engine/tests/fixtures/structural_equals_shape_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/structural_equals_shape_guard.ts rename to crates/submilli-engine/tests/fixtures/structural_equals_shape_guard.ts diff --git a/crates/interpreter/tests/fixtures/structural_interfaces.subm b/crates/submilli-engine/tests/fixtures/structural_interfaces.subm similarity index 100% rename from crates/interpreter/tests/fixtures/structural_interfaces.subm rename to crates/submilli-engine/tests/fixtures/structural_interfaces.subm diff --git a/crates/interpreter/tests/fixtures/structural_visit_budget.ts b/crates/submilli-engine/tests/fixtures/structural_visit_budget.ts similarity index 100% rename from crates/interpreter/tests/fixtures/structural_visit_budget.ts rename to crates/submilli-engine/tests/fixtures/structural_visit_budget.ts diff --git a/crates/interpreter/tests/fixtures/subclass_super_on_every_path.ts b/crates/submilli-engine/tests/fixtures/subclass_super_on_every_path.ts similarity index 100% rename from crates/interpreter/tests/fixtures/subclass_super_on_every_path.ts rename to crates/submilli-engine/tests/fixtures/subclass_super_on_every_path.ts diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm diff --git a/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_assertNever_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/switch_assertNever_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_assertNever_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_assertNever_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_break_in_case.subm b/crates/submilli-engine/tests/fixtures/switch/switch_break_in_case.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_break_in_case.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_break_in_case.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_break_post_state.subm b/crates/submilli-engine/tests/fixtures/switch/switch_break_post_state.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_break_post_state.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_break_post_state.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_default_first.subm b/crates/submilli-engine/tests/fixtures/switch/switch_default_first.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_default_first.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_default_first.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_discriminated_union_narrowing.subm b/crates/submilli-engine/tests/fixtures/switch/switch_discriminated_union_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_discriminated_union_narrowing.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_discriminated_union_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_enum_discriminant.subm b/crates/submilli-engine/tests/fixtures/switch/switch_enum_discriminant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_enum_discriminant.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_enum_discriminant.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm b/crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_string.subm b/crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_string.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_string.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm b/crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm b/crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_literal_union_default_narrows.subm b/crates/submilli-engine/tests/fixtures/switch/switch_literal_union_default_narrows.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_literal_union_default_narrows.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_literal_union_default_narrows.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_literal_union_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/switch_literal_union_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_literal_union_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_literal_union_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_multi_label.subm b/crates/submilli-engine/tests/fixtures/switch/switch_multi_label.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_multi_label.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_multi_label.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_multi_label_discriminated.subm b/crates/submilli-engine/tests/fixtures/switch/switch_multi_label_discriminated.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_multi_label_discriminated.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_multi_label_discriminated.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_multi_label_literal_union.subm b/crates/submilli-engine/tests/fixtures/switch/switch_multi_label_literal_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_multi_label_literal_union.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_multi_label_literal_union.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_no_default.subm b/crates/submilli-engine/tests/fixtures/switch/switch_no_default.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_no_default.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_no_default.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_number_basic.subm b/crates/submilli-engine/tests/fixtures/switch/switch_number_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_number_basic.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_number_basic.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_return_in_case.subm b/crates/submilli-engine/tests/fixtures/switch/switch_return_in_case.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_return_in_case.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_return_in_case.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_string_basic.subm b/crates/submilli-engine/tests/fixtures/switch/switch_string_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_string_basic.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_string_basic.subm diff --git a/crates/interpreter/tests/fixtures/switch/switch_tuple_union_exhaustive.subm b/crates/submilli-engine/tests/fixtures/switch/switch_tuple_union_exhaustive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch/switch_tuple_union_exhaustive.subm rename to crates/submilli-engine/tests/fixtures/switch/switch_tuple_union_exhaustive.subm diff --git a/crates/interpreter/tests/fixtures/switch_case_body_recovery_no_panic.subm b/crates/submilli-engine/tests/fixtures/switch_case_body_recovery_no_panic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch_case_body_recovery_no_panic.subm rename to crates/submilli-engine/tests/fixtures/switch_case_body_recovery_no_panic.subm diff --git a/crates/interpreter/tests/fixtures/switch_case_hex_literal.subm b/crates/submilli-engine/tests/fixtures/switch_case_hex_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/switch_case_hex_literal.subm rename to crates/submilli-engine/tests/fixtures/switch_case_hex_literal.subm diff --git a/crates/interpreter/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts b/crates/submilli-engine/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts rename to crates/submilli-engine/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts diff --git a/crates/interpreter/tests/fixtures/switch_expression_label_duplicates.ts b/crates/submilli-engine/tests/fixtures/switch_expression_label_duplicates.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_expression_label_duplicates.ts rename to crates/submilli-engine/tests/fixtures/switch_expression_label_duplicates.ts diff --git a/crates/interpreter/tests/fixtures/switch_expression_labels.ts b/crates/submilli-engine/tests/fixtures/switch_expression_labels.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_expression_labels.ts rename to crates/submilli-engine/tests/fixtures/switch_expression_labels.ts diff --git a/crates/interpreter/tests/fixtures/switch_function_declarations_hoisted.ts b/crates/submilli-engine/tests/fixtures/switch_function_declarations_hoisted.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_function_declarations_hoisted.ts rename to crates/submilli-engine/tests/fixtures/switch_function_declarations_hoisted.ts diff --git a/crates/interpreter/tests/fixtures/switch_null_assignment_in_loop.ts b/crates/submilli-engine/tests/fixtures/switch_null_assignment_in_loop.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_null_assignment_in_loop.ts rename to crates/submilli-engine/tests/fixtures/switch_null_assignment_in_loop.ts diff --git a/crates/interpreter/tests/fixtures/switch_nullable.ts b/crates/submilli-engine/tests/fixtures/switch_nullable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_nullable.ts rename to crates/submilli-engine/tests/fixtures/switch_nullable.ts diff --git a/crates/interpreter/tests/fixtures/switch_signed_number_labels.ts b/crates/submilli-engine/tests/fixtures/switch_signed_number_labels.ts similarity index 100% rename from crates/interpreter/tests/fixtures/switch_signed_number_labels.ts rename to crates/submilli-engine/tests/fixtures/switch_signed_number_labels.ts diff --git a/crates/interpreter/tests/fixtures/syntax_nesting_near_limit.ts b/crates/submilli-engine/tests/fixtures/syntax_nesting_near_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/syntax_nesting_near_limit.ts rename to crates/submilli-engine/tests/fixtures/syntax_nesting_near_limit.ts diff --git a/crates/interpreter/tests/fixtures/template_generic_null.ts b/crates/submilli-engine/tests/fixtures/template_generic_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_generic_null.ts rename to crates/submilli-engine/tests/fixtures/template_generic_null.ts diff --git a/crates/interpreter/tests/fixtures/template_literal_boolean.subm b/crates/submilli-engine/tests/fixtures/template_literal_boolean.subm similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_boolean.subm rename to crates/submilli-engine/tests/fixtures/template_literal_boolean.subm diff --git a/crates/interpreter/tests/fixtures/template_literal_interface.ts b/crates/submilli-engine/tests/fixtures/template_literal_interface.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_interface.ts rename to crates/submilli-engine/tests/fixtures/template_literal_interface.ts diff --git a/crates/interpreter/tests/fixtures/template_literal_nested.subm b/crates/submilli-engine/tests/fixtures/template_literal_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_nested.subm rename to crates/submilli-engine/tests/fixtures/template_literal_nested.subm diff --git a/crates/interpreter/tests/fixtures/template_literal_no_substitution.subm b/crates/submilli-engine/tests/fixtures/template_literal_no_substitution.subm similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_no_substitution.subm rename to crates/submilli-engine/tests/fixtures/template_literal_no_substitution.subm diff --git a/crates/interpreter/tests/fixtures/template_literal_non_null_assert.ts b/crates/submilli-engine/tests/fixtures/template_literal_non_null_assert.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_non_null_assert.ts rename to crates/submilli-engine/tests/fixtures/template_literal_non_null_assert.ts diff --git a/crates/interpreter/tests/fixtures/template_literal_nullish.ts b/crates/submilli-engine/tests/fixtures/template_literal_nullish.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_nullish.ts rename to crates/submilli-engine/tests/fixtures/template_literal_nullish.ts diff --git a/crates/interpreter/tests/fixtures/template_literal_number.subm b/crates/submilli-engine/tests/fixtures/template_literal_number.subm similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_number.subm rename to crates/submilli-engine/tests/fixtures/template_literal_number.subm diff --git a/crates/interpreter/tests/fixtures/template_literal_string.subm b/crates/submilli-engine/tests/fixtures/template_literal_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_string.subm rename to crates/submilli-engine/tests/fixtures/template_literal_string.subm diff --git a/crates/interpreter/tests/fixtures/template_literal_tuple.ts b/crates/submilli-engine/tests/fixtures/template_literal_tuple.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_literal_tuple.ts rename to crates/submilli-engine/tests/fixtures/template_literal_tuple.ts diff --git a/crates/interpreter/tests/fixtures/template_nesting_near_limit.ts b/crates/submilli-engine/tests/fixtures/template_nesting_near_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_nesting_near_limit.ts rename to crates/submilli-engine/tests/fixtures/template_nesting_near_limit.ts diff --git a/crates/interpreter/tests/fixtures/template_substitution_spans.ts b/crates/submilli-engine/tests/fixtures/template_substitution_spans.ts similarity index 100% rename from crates/interpreter/tests/fixtures/template_substitution_spans.ts rename to crates/submilli-engine/tests/fixtures/template_substitution_spans.ts diff --git a/crates/interpreter/tests/fixtures/temporal/fields_bag_by_interface_type.ts b/crates/submilli-engine/tests/fixtures/temporal/fields_bag_by_interface_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal/fields_bag_by_interface_type.ts rename to crates/submilli-engine/tests/fixtures/temporal/fields_bag_by_interface_type.ts diff --git a/crates/interpreter/tests/fixtures/temporal_compare.subm b/crates/submilli-engine/tests/fixtures/temporal_compare.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_compare.subm rename to crates/submilli-engine/tests/fixtures/temporal_compare.subm diff --git a/crates/interpreter/tests/fixtures/temporal_compare_sort.subm b/crates/submilli-engine/tests/fixtures/temporal_compare_sort.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_compare_sort.subm rename to crates/submilli-engine/tests/fixtures/temporal_compare_sort.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_arithmetic.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_arithmetic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_arithmetic.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_arithmetic.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_compare_from.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_compare_from.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_compare_from.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_compare_from.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_from_iso.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_from_iso.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_from_iso.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_from_iso.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_host_validation.ts b/crates/submilli-engine/tests/fixtures/temporal_duration_host_validation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_host_validation.ts rename to crates/submilli-engine/tests/fixtures/temporal_duration_host_validation.ts diff --git a/crates/interpreter/tests/fixtures/temporal_duration_like_arg.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_like_arg.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_like_arg.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_like_arg.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_object_literal.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_object_literal.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_object_literal.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_object_literal.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_round_total.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_round_total.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_round_total.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_round_total.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_sign.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_sign.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_sign.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_sign.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_to_string_options.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_to_string_options.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_to_string_options.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_to_string_options.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_with_abs_blank.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_with_abs_blank.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_with_abs_blank.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_with_abs_blank.subm diff --git a/crates/interpreter/tests/fixtures/temporal_duration_zdt_anchor.subm b/crates/submilli-engine/tests/fixtures/temporal_duration_zdt_anchor.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_duration_zdt_anchor.subm rename to crates/submilli-engine/tests/fixtures/temporal_duration_zdt_anchor.subm diff --git a/crates/interpreter/tests/fixtures/temporal_error_messages.subm b/crates/submilli-engine/tests/fixtures/temporal_error_messages.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_error_messages.subm rename to crates/submilli-engine/tests/fixtures/temporal_error_messages.subm diff --git a/crates/interpreter/tests/fixtures/temporal_errors_are_catchable.subm b/crates/submilli-engine/tests/fixtures/temporal_errors_are_catchable.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_errors_are_catchable.subm rename to crates/submilli-engine/tests/fixtures/temporal_errors_are_catchable.subm diff --git a/crates/interpreter/tests/fixtures/temporal_getters.subm b/crates/submilli-engine/tests/fixtures/temporal_getters.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_getters.subm rename to crates/submilli-engine/tests/fixtures/temporal_getters.subm diff --git a/crates/interpreter/tests/fixtures/temporal_hook_contract.ts b/crates/submilli-engine/tests/fixtures/temporal_hook_contract.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_hook_contract.ts rename to crates/submilli-engine/tests/fixtures/temporal_hook_contract.ts diff --git a/crates/interpreter/tests/fixtures/temporal_instant_arithmetic.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_arithmetic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_arithmetic.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_arithmetic.subm diff --git a/crates/interpreter/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm diff --git a/crates/interpreter/tests/fixtures/temporal_instant_equals.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_equals.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_equals.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_equals.subm diff --git a/crates/interpreter/tests/fixtures/temporal_instant_from_epoch.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_from_epoch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_from_epoch.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_from_epoch.subm diff --git a/crates/interpreter/tests/fixtures/temporal_instant_iso_round_trip.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_iso_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_iso_round_trip.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_iso_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/temporal_instant_round.subm b/crates/submilli-engine/tests/fixtures/temporal_instant_round.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_instant_round.subm rename to crates/submilli-engine/tests/fixtures/temporal_instant_round.subm diff --git a/crates/interpreter/tests/fixtures/temporal_long_duration.subm b/crates/submilli-engine/tests/fixtures/temporal_long_duration.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_long_duration.subm rename to crates/submilli-engine/tests/fixtures/temporal_long_duration.subm diff --git a/crates/interpreter/tests/fixtures/temporal_negative_duration.subm b/crates/submilli-engine/tests/fixtures/temporal_negative_duration.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_negative_duration.subm rename to crates/submilli-engine/tests/fixtures/temporal_negative_duration.subm diff --git a/crates/interpreter/tests/fixtures/temporal_now_plain.subm b/crates/submilli-engine/tests/fixtures/temporal_now_plain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_now_plain.subm rename to crates/submilli-engine/tests/fixtures/temporal_now_plain.subm diff --git a/crates/interpreter/tests/fixtures/temporal_now_smoke.subm b/crates/submilli-engine/tests/fixtures/temporal_now_smoke.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_now_smoke.subm rename to crates/submilli-engine/tests/fixtures/temporal_now_smoke.subm diff --git a/crates/interpreter/tests/fixtures/temporal_now_time_zone_id.subm b/crates/submilli-engine/tests/fixtures/temporal_now_time_zone_id.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_now_time_zone_id.subm rename to crates/submilli-engine/tests/fixtures/temporal_now_time_zone_id.subm diff --git a/crates/interpreter/tests/fixtures/temporal_now_zoned_date_time_iso.subm b/crates/submilli-engine/tests/fixtures/temporal_now_zoned_date_time_iso.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_now_zoned_date_time_iso.subm rename to crates/submilli-engine/tests/fixtures/temporal_now_zoned_date_time_iso.subm diff --git a/crates/interpreter/tests/fixtures/temporal_numeric_range_validation.ts b/crates/submilli-engine/tests/fixtures/temporal_numeric_range_validation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_numeric_range_validation.ts rename to crates/submilli-engine/tests/fixtures/temporal_numeric_range_validation.ts diff --git a/crates/interpreter/tests/fixtures/temporal_options_interface_arg.ts b/crates/submilli-engine/tests/fixtures/temporal_options_interface_arg.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_options_interface_arg.ts rename to crates/submilli-engine/tests/fixtures/temporal_options_interface_arg.ts diff --git a/crates/interpreter/tests/fixtures/temporal_plain_arithmetic.subm b/crates/submilli-engine/tests/fixtures/temporal_plain_arithmetic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plain_arithmetic.subm rename to crates/submilli-engine/tests/fixtures/temporal_plain_arithmetic.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plain_erased_boundaries.ts b/crates/submilli-engine/tests/fixtures/temporal_plain_erased_boundaries.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plain_erased_boundaries.ts rename to crates/submilli-engine/tests/fixtures/temporal_plain_erased_boundaries.ts diff --git a/crates/interpreter/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm b/crates/submilli-engine/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm rename to crates/submilli-engine/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plain_to_zoned.subm b/crates/submilli-engine/tests/fixtures/temporal_plain_to_zoned.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plain_to_zoned.subm rename to crates/submilli-engine/tests/fixtures/temporal_plain_to_zoned.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plaindate.subm b/crates/submilli-engine/tests/fixtures/temporal_plaindate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plaindate.subm rename to crates/submilli-engine/tests/fixtures/temporal_plaindate.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plaindate_to_plaindatetime.subm b/crates/submilli-engine/tests/fixtures/temporal_plaindate_to_plaindatetime.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plaindate_to_plaindatetime.subm rename to crates/submilli-engine/tests/fixtures/temporal_plaindate_to_plaindatetime.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plaindatetime.subm b/crates/submilli-engine/tests/fixtures/temporal_plaindatetime.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plaindatetime.subm rename to crates/submilli-engine/tests/fixtures/temporal_plaindatetime.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plainmonthday.subm b/crates/submilli-engine/tests/fixtures/temporal_plainmonthday.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plainmonthday.subm rename to crates/submilli-engine/tests/fixtures/temporal_plainmonthday.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plaintime.subm b/crates/submilli-engine/tests/fixtures/temporal_plaintime.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plaintime.subm rename to crates/submilli-engine/tests/fixtures/temporal_plaintime.subm diff --git a/crates/interpreter/tests/fixtures/temporal_plainyearmonth.subm b/crates/submilli-engine/tests/fixtures/temporal_plainyearmonth.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_plainyearmonth.subm rename to crates/submilli-engine/tests/fixtures/temporal_plainyearmonth.subm diff --git a/crates/interpreter/tests/fixtures/temporal_to_json.subm b/crates/submilli-engine/tests/fixtures/temporal_to_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_to_json.subm rename to crates/submilli-engine/tests/fixtures/temporal_to_json.subm diff --git a/crates/interpreter/tests/fixtures/temporal_until_options.subm b/crates/submilli-engine/tests/fixtures/temporal_until_options.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_until_options.subm rename to crates/submilli-engine/tests/fixtures/temporal_until_options.subm diff --git a/crates/interpreter/tests/fixtures/temporal_with.subm b/crates/submilli-engine/tests/fixtures/temporal_with.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_with.subm rename to crates/submilli-engine/tests/fixtures/temporal_with.subm diff --git a/crates/interpreter/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm b/crates/submilli-engine/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm rename to crates/submilli-engine/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_alias_identity.ts b/crates/submilli-engine/tests/fixtures/temporal_zdt_alias_identity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_alias_identity.ts rename to crates/submilli-engine/tests/fixtures/temporal_zdt_alias_identity.ts diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_dst_spring_forward.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_dst_spring_forward.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_dst_spring_forward.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_dst_spring_forward.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_equals.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_equals.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_equals.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_equals.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_from_iso.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_from_iso.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_from_iso.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_from_iso.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_host_complete.ts b/crates/submilli-engine/tests/fixtures/temporal_zdt_host_complete.ts similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_host_complete.ts rename to crates/submilli-engine/tests/fixtures/temporal_zdt_host_complete.ts diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_to_instant.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_to_instant.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_to_instant.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_to_instant.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_to_plain.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_to_plain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_to_plain.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_to_plain.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zdt_with_time_zone.subm b/crates/submilli-engine/tests/fixtures/temporal_zdt_with_time_zone.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zdt_with_time_zone.subm rename to crates/submilli-engine/tests/fixtures/temporal_zdt_with_time_zone.subm diff --git a/crates/interpreter/tests/fixtures/temporal_zoned_round_trip.subm b/crates/submilli-engine/tests/fixtures/temporal_zoned_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/temporal_zoned_round_trip.subm rename to crates/submilli-engine/tests/fixtures/temporal_zoned_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/ternary/expect_error_missing_colon.subm b/crates/submilli-engine/tests/fixtures/ternary/expect_error_missing_colon.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/expect_error_missing_colon.subm rename to crates/submilli-engine/tests/fixtures/ternary/expect_error_missing_colon.subm diff --git a/crates/interpreter/tests/fixtures/ternary/logical_branches.ts b/crates/submilli-engine/tests/fixtures/ternary/logical_branches.ts similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/logical_branches.ts rename to crates/submilli-engine/tests/fixtures/ternary/logical_branches.ts diff --git a/crates/interpreter/tests/fixtures/ternary/narrowing.subm b/crates/submilli-engine/tests/fixtures/ternary/narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/narrowing.subm rename to crates/submilli-engine/tests/fixtures/ternary/narrowing.subm diff --git a/crates/interpreter/tests/fixtures/ternary/nested.subm b/crates/submilli-engine/tests/fixtures/ternary/nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/nested.subm rename to crates/submilli-engine/tests/fixtures/ternary/nested.subm diff --git a/crates/interpreter/tests/fixtures/ternary/simple.subm b/crates/submilli-engine/tests/fixtures/ternary/simple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/simple.subm rename to crates/submilli-engine/tests/fixtures/ternary/simple.subm diff --git a/crates/interpreter/tests/fixtures/ternary/truthiness_cond.subm b/crates/submilli-engine/tests/fixtures/ternary/truthiness_cond.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/truthiness_cond.subm rename to crates/submilli-engine/tests/fixtures/ternary/truthiness_cond.subm diff --git a/crates/interpreter/tests/fixtures/ternary/void_branches.ts b/crates/submilli-engine/tests/fixtures/ternary/void_branches.ts similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/void_branches.ts rename to crates/submilli-engine/tests/fixtures/ternary/void_branches.ts diff --git a/crates/interpreter/tests/fixtures/ternary/with_optional_chain.subm b/crates/submilli-engine/tests/fixtures/ternary/with_optional_chain.subm similarity index 100% rename from crates/interpreter/tests/fixtures/ternary/with_optional_chain.subm rename to crates/submilli-engine/tests/fixtures/ternary/with_optional_chain.subm diff --git a/crates/interpreter/tests/fixtures/text_codec_unicode.subm b/crates/submilli-engine/tests/fixtures/text_codec_unicode.subm similarity index 100% rename from crates/interpreter/tests/fixtures/text_codec_unicode.subm rename to crates/submilli-engine/tests/fixtures/text_codec_unicode.subm diff --git a/crates/interpreter/tests/fixtures/text_codec_with_base64.subm b/crates/submilli-engine/tests/fixtures/text_codec_with_base64.subm similarity index 100% rename from crates/interpreter/tests/fixtures/text_codec_with_base64.subm rename to crates/submilli-engine/tests/fixtures/text_codec_with_base64.subm diff --git a/crates/interpreter/tests/fixtures/text_encoder_round_trip.subm b/crates/submilli-engine/tests/fixtures/text_encoder_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/text_encoder_round_trip.subm rename to crates/submilli-engine/tests/fixtures/text_encoder_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/to_json_record_non_string_throws.ts b/crates/submilli-engine/tests/fixtures/to_json_record_non_string_throws.ts similarity index 100% rename from crates/interpreter/tests/fixtures/to_json_record_non_string_throws.ts rename to crates/submilli-engine/tests/fixtures/to_json_record_non_string_throws.ts diff --git a/crates/interpreter/tests/fixtures/top_level_function_identity.ts b/crates/submilli-engine/tests/fixtures/top_level_function_identity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/top_level_function_identity.ts rename to crates/submilli-engine/tests/fixtures/top_level_function_identity.ts diff --git a/crates/interpreter/tests/fixtures/tostring_default_still_works.subm b/crates/submilli-engine/tests/fixtures/tostring_default_still_works.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tostring_default_still_works.subm rename to crates/submilli-engine/tests/fixtures/tostring_default_still_works.subm diff --git a/crates/interpreter/tests/fixtures/tostring_field_override.subm b/crates/submilli-engine/tests/fixtures/tostring_field_override.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tostring_field_override.subm rename to crates/submilli-engine/tests/fixtures/tostring_field_override.subm diff --git a/crates/interpreter/tests/fixtures/tostring_field_override_with_capture.subm b/crates/submilli-engine/tests/fixtures/tostring_field_override_with_capture.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tostring_field_override_with_capture.subm rename to crates/submilli-engine/tests/fixtures/tostring_field_override_with_capture.subm diff --git a/crates/interpreter/tests/fixtures/trailing_commas.subm b/crates/submilli-engine/tests/fixtures/trailing_commas.subm similarity index 100% rename from crates/interpreter/tests/fixtures/trailing_commas.subm rename to crates/submilli-engine/tests/fixtures/trailing_commas.subm diff --git a/crates/interpreter/tests/fixtures/truthiness/always_truthy.ts b/crates/submilli-engine/tests/fixtures/truthiness/always_truthy.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/always_truthy.ts rename to crates/submilli-engine/tests/fixtures/truthiness/always_truthy.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/and_value.ts b/crates/submilli-engine/tests/fixtures/truthiness/and_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/and_value.ts rename to crates/submilli-engine/tests/fixtures/truthiness/and_value.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/bigint_cond.ts b/crates/submilli-engine/tests/fixtures/truthiness/bigint_cond.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/bigint_cond.ts rename to crates/submilli-engine/tests/fixtures/truthiness/bigint_cond.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/boolean_or_null.ts b/crates/submilli-engine/tests/fixtures/truthiness/boolean_or_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/boolean_or_null.ts rename to crates/submilli-engine/tests/fixtures/truthiness/boolean_or_null.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/false_branch_keeps_type.ts b/crates/submilli-engine/tests/fixtures/truthiness/false_branch_keeps_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/false_branch_keeps_type.ts rename to crates/submilli-engine/tests/fixtures/truthiness/false_branch_keeps_type.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/logical_in_condition.ts b/crates/submilli-engine/tests/fixtures/truthiness/logical_in_condition.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/logical_in_condition.ts rename to crates/submilli-engine/tests/fixtures/truthiness/logical_in_condition.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/number_cond.ts b/crates/submilli-engine/tests/fixtures/truthiness/number_cond.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/number_cond.ts rename to crates/submilli-engine/tests/fixtures/truthiness/number_cond.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/or_default.ts b/crates/submilli-engine/tests/fixtures/truthiness/or_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/or_default.ts rename to crates/submilli-engine/tests/fixtures/truthiness/or_default.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/string_cond.ts b/crates/submilli-engine/tests/fixtures/truthiness/string_cond.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/string_cond.ts rename to crates/submilli-engine/tests/fixtures/truthiness/string_cond.ts diff --git a/crates/interpreter/tests/fixtures/truthiness/string_or_null_empty.ts b/crates/submilli-engine/tests/fixtures/truthiness/string_or_null_empty.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness/string_or_null_empty.ts rename to crates/submilli-engine/tests/fixtures/truthiness/string_or_null_empty.ts diff --git a/crates/interpreter/tests/fixtures/truthiness_rules_out_to_never.ts b/crates/submilli-engine/tests/fixtures/truthiness_rules_out_to_never.ts similarity index 100% rename from crates/interpreter/tests/fixtures/truthiness_rules_out_to_never.ts rename to crates/submilli-engine/tests/fixtures/truthiness_rules_out_to_never.ts diff --git a/crates/interpreter/tests/fixtures/ts_single.ts b/crates/submilli-engine/tests/fixtures/ts_single.ts similarity index 100% rename from crates/interpreter/tests/fixtures/ts_single.ts rename to crates/submilli-engine/tests/fixtures/ts_single.ts diff --git a/crates/interpreter/tests/fixtures/tuple_as_array.subm b/crates/submilli-engine/tests/fixtures/tuple_as_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_as_array.subm rename to crates/submilli-engine/tests/fixtures/tuple_as_array.subm diff --git a/crates/interpreter/tests/fixtures/tuple_as_iterable_source.ts b/crates/submilli-engine/tests/fixtures/tuple_as_iterable_source.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_as_iterable_source.ts rename to crates/submilli-engine/tests/fixtures/tuple_as_iterable_source.ts diff --git a/crates/interpreter/tests/fixtures/tuple_basic.subm b/crates/submilli-engine/tests/fixtures/tuple_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_basic.subm rename to crates/submilli-engine/tests/fixtures/tuple_basic.subm diff --git a/crates/interpreter/tests/fixtures/tuple_in_array.subm b/crates/submilli-engine/tests/fixtures/tuple_in_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_in_array.subm rename to crates/submilli-engine/tests/fixtures/tuple_in_array.subm diff --git a/crates/interpreter/tests/fixtures/tuple_json_stringify.subm b/crates/submilli-engine/tests/fixtures/tuple_json_stringify.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_json_stringify.subm rename to crates/submilli-engine/tests/fixtures/tuple_json_stringify.subm diff --git a/crates/interpreter/tests/fixtures/tuple_labels.ts b/crates/submilli-engine/tests/fixtures/tuple_labels.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_labels.ts rename to crates/submilli-engine/tests/fixtures/tuple_labels.ts diff --git a/crates/interpreter/tests/fixtures/tuple_length.subm b/crates/submilli-engine/tests/fixtures/tuple_length.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_length.subm rename to crates/submilli-engine/tests/fixtures/tuple_length.subm diff --git a/crates/interpreter/tests/fixtures/tuple_methods.subm b/crates/submilli-engine/tests/fixtures/tuple_methods.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_methods.subm rename to crates/submilli-engine/tests/fixtures/tuple_methods.subm diff --git a/crates/interpreter/tests/fixtures/tuple_nested.subm b/crates/submilli-engine/tests/fixtures/tuple_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_nested.subm rename to crates/submilli-engine/tests/fixtures/tuple_nested.subm diff --git a/crates/interpreter/tests/fixtures/tuple_union_index_access.subm b/crates/submilli-engine/tests/fixtures/tuple_union_index_access.subm similarity index 100% rename from crates/interpreter/tests/fixtures/tuple_union_index_access.subm rename to crates/submilli-engine/tests/fixtures/tuple_union_index_access.subm diff --git a/crates/interpreter/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts b/crates/submilli-engine/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts rename to crates/submilli-engine/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts diff --git a/crates/interpreter/tests/fixtures/tuples/issue_988_arity.ts b/crates/submilli-engine/tests/fixtures/tuples/issue_988_arity.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/issue_988_arity.ts rename to crates/submilli-engine/tests/fixtures/tuples/issue_988_arity.ts diff --git a/crates/interpreter/tests/fixtures/tuples/issue_988_correlation.ts b/crates/submilli-engine/tests/fixtures/tuples/issue_988_correlation.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/issue_988_correlation.ts rename to crates/submilli-engine/tests/fixtures/tuples/issue_988_correlation.ts diff --git a/crates/interpreter/tests/fixtures/tuples/issue_988_union_context.ts b/crates/submilli-engine/tests/fixtures/tuples/issue_988_union_context.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/issue_988_union_context.ts rename to crates/submilli-engine/tests/fixtures/tuples/issue_988_union_context.ts diff --git a/crates/interpreter/tests/fixtures/tuples/optional_elements.ts b/crates/submilli-engine/tests/fixtures/tuples/optional_elements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/optional_elements.ts rename to crates/submilli-engine/tests/fixtures/tuples/optional_elements.ts diff --git a/crates/interpreter/tests/fixtures/tuples/required_undefined_to_optional.ts b/crates/submilli-engine/tests/fixtures/tuples/required_undefined_to_optional.ts similarity index 100% rename from crates/interpreter/tests/fixtures/tuples/required_undefined_to_optional.ts rename to crates/submilli-engine/tests/fixtures/tuples/required_undefined_to_optional.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/alias_null_in_union.subm b/crates/submilli-engine/tests/fixtures/type-aliases/alias_null_in_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/alias_null_in_union.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/alias_null_in_union.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/alias_string_host_call.subm b/crates/submilli-engine/tests/fixtures/type-aliases/alias_string_host_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/alias_string_host_call.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/alias_string_host_call.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/alias_tuple_literal_return.ts b/crates/submilli-engine/tests/fixtures/type-aliases/alias_tuple_literal_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/alias_tuple_literal_return.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/alias_tuple_literal_return.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/alias_union_dedup.ts b/crates/submilli-engine/tests/fixtures/type-aliases/alias_union_dedup.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/alias_union_dedup.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/alias_union_dedup.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/aliased_function_type_const.subm b/crates/submilli-engine/tests/fixtures/type-aliases/aliased_function_type_const.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/aliased_function_type_const.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/aliased_function_type_const.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/aliased_void_return.ts b/crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_return.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/aliased_void_return.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_return.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/aliased_void_value.ts b/crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/aliased_void_value.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_value.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm b/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts b/crates/submilli-engine/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/generic_alias_box.subm b/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_box.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/generic_alias_box.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_box.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm b/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/generic_alias_nested.subm b/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/generic_alias_nested.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_nested.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/generic_alias_pair.subm b/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_pair.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/generic_alias_pair.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_pair.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts b/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts rename to crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts diff --git a/crates/interpreter/tests/fixtures/type-aliases/non_generic_alias_nested.subm b/crates/submilli-engine/tests/fixtures/type-aliases/non_generic_alias_nested.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/non_generic_alias_nested.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/non_generic_alias_nested.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/type_alias_array.subm b/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/type_alias_array.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/type_alias_array.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/type_alias_discriminated_union.subm b/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_discriminated_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/type_alias_discriminated_union.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/type_alias_discriminated_union.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/type_alias_object.subm b/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_object.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/type_alias_object.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/type_alias_object.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/type_alias_primitive.subm b/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_primitive.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/type_alias_primitive.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/type_alias_primitive.subm diff --git a/crates/interpreter/tests/fixtures/type-aliases/type_alias_union.subm b/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_union.subm similarity index 100% rename from crates/interpreter/tests/fixtures/type-aliases/type_alias_union.subm rename to crates/submilli-engine/tests/fixtures/type-aliases/type_alias_union.subm diff --git a/crates/interpreter/tests/fixtures/type_guard_rendering_names_the_loss.ts b/crates/submilli-engine/tests/fixtures/type_guard_rendering_names_the_loss.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type_guard_rendering_names_the_loss.ts rename to crates/submilli-engine/tests/fixtures/type_guard_rendering_names_the_loss.ts diff --git a/crates/interpreter/tests/fixtures/type_member_line_breaks.ts b/crates/submilli-engine/tests/fixtures/type_member_line_breaks.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type_member_line_breaks.ts rename to crates/submilli-engine/tests/fixtures/type_member_line_breaks.ts diff --git a/crates/interpreter/tests/fixtures/type_members_named_like_keywords.ts b/crates/submilli-engine/tests/fixtures/type_members_named_like_keywords.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type_members_named_like_keywords.ts rename to crates/submilli-engine/tests/fixtures/type_members_named_like_keywords.ts diff --git a/crates/interpreter/tests/fixtures/type_size_near_limit.ts b/crates/submilli-engine/tests/fixtures/type_size_near_limit.ts similarity index 100% rename from crates/interpreter/tests/fixtures/type_size_near_limit.ts rename to crates/submilli-engine/tests/fixtures/type_size_near_limit.ts diff --git a/crates/interpreter/tests/fixtures/typeof_alone.subm b/crates/submilli-engine/tests/fixtures/typeof_alone.subm similarity index 100% rename from crates/interpreter/tests/fixtures/typeof_alone.subm rename to crates/submilli-engine/tests/fixtures/typeof_alone.subm diff --git a/crates/interpreter/tests/fixtures/typeof_enum_member.ts b/crates/submilli-engine/tests/fixtures/typeof_enum_member.ts similarity index 100% rename from crates/interpreter/tests/fixtures/typeof_enum_member.ts rename to crates/submilli-engine/tests/fixtures/typeof_enum_member.ts diff --git a/crates/interpreter/tests/fixtures/typeof_function_narrows_union.ts b/crates/submilli-engine/tests/fixtures/typeof_function_narrows_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/typeof_function_narrows_union.ts rename to crates/submilli-engine/tests/fixtures/typeof_function_narrows_union.ts diff --git a/crates/interpreter/tests/fixtures/typeof_type_query.ts b/crates/submilli-engine/tests/fixtures/typeof_type_query.ts similarity index 100% rename from crates/interpreter/tests/fixtures/typeof_type_query.ts rename to crates/submilli-engine/tests/fixtures/typeof_type_query.ts diff --git a/crates/interpreter/tests/fixtures/typeof_undefined_type_query.ts b/crates/submilli-engine/tests/fixtures/typeof_undefined_type_query.ts similarity index 100% rename from crates/interpreter/tests/fixtures/typeof_undefined_type_query.ts rename to crates/submilli-engine/tests/fixtures/typeof_undefined_type_query.ts diff --git a/crates/interpreter/tests/fixtures/types/expect_error_any_not_supported.ts b/crates/submilli-engine/tests/fixtures/types/expect_error_any_not_supported.ts similarity index 100% rename from crates/interpreter/tests/fixtures/types/expect_error_any_not_supported.ts rename to crates/submilli-engine/tests/fixtures/types/expect_error_any_not_supported.ts diff --git a/crates/interpreter/tests/fixtures/types/expect_error_bare_function_type_params.ts b/crates/submilli-engine/tests/fixtures/types/expect_error_bare_function_type_params.ts similarity index 100% rename from crates/interpreter/tests/fixtures/types/expect_error_bare_function_type_params.ts rename to crates/submilli-engine/tests/fixtures/types/expect_error_bare_function_type_params.ts diff --git a/crates/interpreter/tests/fixtures/types/expect_error_function_type_param_typo.ts b/crates/submilli-engine/tests/fixtures/types/expect_error_function_type_param_typo.ts similarity index 100% rename from crates/interpreter/tests/fixtures/types/expect_error_function_type_param_typo.ts rename to crates/submilli-engine/tests/fixtures/types/expect_error_function_type_param_typo.ts diff --git a/crates/interpreter/tests/fixtures/types/expect_error_unclosed_grouped_type.ts b/crates/submilli-engine/tests/fixtures/types/expect_error_unclosed_grouped_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/types/expect_error_unclosed_grouped_type.ts rename to crates/submilli-engine/tests/fixtures/types/expect_error_unclosed_grouped_type.ts diff --git a/crates/interpreter/tests/fixtures/types/parenthesized_type.ts b/crates/submilli-engine/tests/fixtures/types/parenthesized_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/types/parenthesized_type.ts rename to crates/submilli-engine/tests/fixtures/types/parenthesized_type.ts diff --git a/crates/interpreter/tests/fixtures/uint8array_alloc.subm b/crates/submilli-engine/tests/fixtures/uint8array_alloc.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_alloc.subm rename to crates/submilli-engine/tests/fixtures/uint8array_alloc.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_at.subm b/crates/submilli-engine/tests/fixtures/uint8array_at.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_at.subm rename to crates/submilli-engine/tests/fixtures/uint8array_at.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_base64.subm b/crates/submilli-engine/tests/fixtures/uint8array_base64.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_base64.subm rename to crates/submilli-engine/tests/fixtures/uint8array_base64.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_base64_options.subm b/crates/submilli-engine/tests/fixtures/uint8array_base64_options.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_base64_options.subm rename to crates/submilli-engine/tests/fixtures/uint8array_base64_options.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_byte_length.subm b/crates/submilli-engine/tests/fixtures/uint8array_byte_length.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_byte_length.subm rename to crates/submilli-engine/tests/fixtures/uint8array_byte_length.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_copy_within.subm b/crates/submilli-engine/tests/fixtures/uint8array_copy_within.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_copy_within.subm rename to crates/submilli-engine/tests/fixtures/uint8array_copy_within.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_equals.subm b/crates/submilli-engine/tests/fixtures/uint8array_equals.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_equals.subm rename to crates/submilli-engine/tests/fixtures/uint8array_equals.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_fill.subm b/crates/submilli-engine/tests/fixtures/uint8array_fill.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_fill.subm rename to crates/submilli-engine/tests/fixtures/uint8array_fill.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_filter.subm b/crates/submilli-engine/tests/fixtures/uint8array_filter.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_filter.subm rename to crates/submilli-engine/tests/fixtures/uint8array_filter.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_find.subm b/crates/submilli-engine/tests/fixtures/uint8array_find.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_find.subm rename to crates/submilli-engine/tests/fixtures/uint8array_find.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_for_each.subm b/crates/submilli-engine/tests/fixtures/uint8array_for_each.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_for_each.subm rename to crates/submilli-engine/tests/fixtures/uint8array_for_each.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_from_array.subm b/crates/submilli-engine/tests/fixtures/uint8array_from_array.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_from_array.subm rename to crates/submilli-engine/tests/fixtures/uint8array_from_array.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_from_bytes.subm b/crates/submilli-engine/tests/fixtures/uint8array_from_bytes.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_from_bytes.subm rename to crates/submilli-engine/tests/fixtures/uint8array_from_bytes.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_from_hex_errors.subm b/crates/submilli-engine/tests/fixtures/uint8array_from_hex_errors.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_from_hex_errors.subm rename to crates/submilli-engine/tests/fixtures/uint8array_from_hex_errors.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_hex.subm b/crates/submilli-engine/tests/fixtures/uint8array_hex.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_hex.subm rename to crates/submilli-engine/tests/fixtures/uint8array_hex.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_host_vtable.ts b/crates/submilli-engine/tests/fixtures/uint8array_host_vtable.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_host_vtable.ts rename to crates/submilli-engine/tests/fixtures/uint8array_host_vtable.ts diff --git a/crates/interpreter/tests/fixtures/uint8array_index_bounds.ts b/crates/submilli-engine/tests/fixtures/uint8array_index_bounds.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_index_bounds.ts rename to crates/submilli-engine/tests/fixtures/uint8array_index_bounds.ts diff --git a/crates/interpreter/tests/fixtures/uint8array_index_of.subm b/crates/submilli-engine/tests/fixtures/uint8array_index_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_index_of.subm rename to crates/submilli-engine/tests/fixtures/uint8array_index_of.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_indexed_write.subm b/crates/submilli-engine/tests/fixtures/uint8array_indexed_write.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_indexed_write.subm rename to crates/submilli-engine/tests/fixtures/uint8array_indexed_write.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_join.subm b/crates/submilli-engine/tests/fixtures/uint8array_join.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_join.subm rename to crates/submilli-engine/tests/fixtures/uint8array_join.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_map.subm b/crates/submilli-engine/tests/fixtures/uint8array_map.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_map.subm rename to crates/submilli-engine/tests/fixtures/uint8array_map.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_new.subm b/crates/submilli-engine/tests/fixtures/uint8array_new.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_new.subm rename to crates/submilli-engine/tests/fixtures/uint8array_new.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_new_length.ts b/crates/submilli-engine/tests/fixtures/uint8array_new_length.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_new_length.ts rename to crates/submilli-engine/tests/fixtures/uint8array_new_length.ts diff --git a/crates/interpreter/tests/fixtures/uint8array_of.subm b/crates/submilli-engine/tests/fixtures/uint8array_of.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_of.subm rename to crates/submilli-engine/tests/fixtures/uint8array_of.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_ranged_mutations.ts b/crates/submilli-engine/tests/fixtures/uint8array_ranged_mutations.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_ranged_mutations.ts rename to crates/submilli-engine/tests/fixtures/uint8array_ranged_mutations.ts diff --git a/crates/interpreter/tests/fixtures/uint8array_reduce.subm b/crates/submilli-engine/tests/fixtures/uint8array_reduce.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_reduce.subm rename to crates/submilli-engine/tests/fixtures/uint8array_reduce.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_reverse.subm b/crates/submilli-engine/tests/fixtures/uint8array_reverse.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_reverse.subm rename to crates/submilli-engine/tests/fixtures/uint8array_reverse.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_set.subm b/crates/submilli-engine/tests/fixtures/uint8array_set.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_set.subm rename to crates/submilli-engine/tests/fixtures/uint8array_set.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_set_out_of_range.subm b/crates/submilli-engine/tests/fixtures/uint8array_set_out_of_range.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_set_out_of_range.subm rename to crates/submilli-engine/tests/fixtures/uint8array_set_out_of_range.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_slice.subm b/crates/submilli-engine/tests/fixtures/uint8array_slice.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_slice.subm rename to crates/submilli-engine/tests/fixtures/uint8array_slice.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_some_every.subm b/crates/submilli-engine/tests/fixtures/uint8array_some_every.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_some_every.subm rename to crates/submilli-engine/tests/fixtures/uint8array_some_every.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_sort.subm b/crates/submilli-engine/tests/fixtures/uint8array_sort.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_sort.subm rename to crates/submilli-engine/tests/fixtures/uint8array_sort.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_subarray.subm b/crates/submilli-engine/tests/fixtures/uint8array_subarray.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_subarray.subm rename to crates/submilli-engine/tests/fixtures/uint8array_subarray.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_to_json.subm b/crates/submilli-engine/tests/fixtures/uint8array_to_json.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_to_json.subm rename to crates/submilli-engine/tests/fixtures/uint8array_to_json.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_to_reversed.subm b/crates/submilli-engine/tests/fixtures/uint8array_to_reversed.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_to_reversed.subm rename to crates/submilli-engine/tests/fixtures/uint8array_to_reversed.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_to_sorted.subm b/crates/submilli-engine/tests/fixtures/uint8array_to_sorted.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_to_sorted.subm rename to crates/submilli-engine/tests/fixtures/uint8array_to_sorted.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_to_string.subm b/crates/submilli-engine/tests/fixtures/uint8array_to_string.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_to_string.subm rename to crates/submilli-engine/tests/fixtures/uint8array_to_string.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_truncate.subm b/crates/submilli-engine/tests/fixtures/uint8array_truncate.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_truncate.subm rename to crates/submilli-engine/tests/fixtures/uint8array_truncate.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_with.subm b/crates/submilli-engine/tests/fixtures/uint8array_with.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_with.subm rename to crates/submilli-engine/tests/fixtures/uint8array_with.subm diff --git a/crates/interpreter/tests/fixtures/uint8array_wraps_like_to_uint8.ts b/crates/submilli-engine/tests/fixtures/uint8array_wraps_like_to_uint8.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uint8array_wraps_like_to_uint8.ts rename to crates/submilli-engine/tests/fixtures/uint8array_wraps_like_to_uint8.ts diff --git a/crates/interpreter/tests/fixtures/unary_plus_string.ts b/crates/submilli-engine/tests/fixtures/unary_plus_string.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unary_plus_string.ts rename to crates/submilli-engine/tests/fixtures/unary_plus_string.ts diff --git a/crates/interpreter/tests/fixtures/undefined/defaults.ts b/crates/submilli-engine/tests/fixtures/undefined/defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/defaults.ts rename to crates/submilli-engine/tests/fixtures/undefined/defaults.ts diff --git a/crates/interpreter/tests/fixtures/undefined/expect_error_required.ts b/crates/submilli-engine/tests/fixtures/undefined/expect_error_required.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/expect_error_required.ts rename to crates/submilli-engine/tests/fixtures/undefined/expect_error_required.ts diff --git a/crates/interpreter/tests/fixtures/undefined/expect_error_required_argument.ts b/crates/submilli-engine/tests/fixtures/undefined/expect_error_required_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/expect_error_required_argument.ts rename to crates/submilli-engine/tests/fixtures/undefined/expect_error_required_argument.ts diff --git a/crates/interpreter/tests/fixtures/undefined/methods.ts b/crates/submilli-engine/tests/fixtures/undefined/methods.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/methods.ts rename to crates/submilli-engine/tests/fixtures/undefined/methods.ts diff --git a/crates/interpreter/tests/fixtures/undefined/primitives.ts b/crates/submilli-engine/tests/fixtures/undefined/primitives.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/primitives.ts rename to crates/submilli-engine/tests/fixtures/undefined/primitives.ts diff --git a/crates/interpreter/tests/fixtures/undefined/properties.ts b/crates/submilli-engine/tests/fixtures/undefined/properties.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined/properties.ts rename to crates/submilli-engine/tests/fixtures/undefined/properties.ts diff --git a/crates/interpreter/tests/fixtures/undefined_array_literal_elements.ts b/crates/submilli-engine/tests/fixtures/undefined_array_literal_elements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_array_literal_elements.ts rename to crates/submilli-engine/tests/fixtures/undefined_array_literal_elements.ts diff --git a/crates/interpreter/tests/fixtures/undefined_array_literal_nullish_lead.ts b/crates/submilli-engine/tests/fixtures/undefined_array_literal_nullish_lead.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_array_literal_nullish_lead.ts rename to crates/submilli-engine/tests/fixtures/undefined_array_literal_nullish_lead.ts diff --git a/crates/interpreter/tests/fixtures/undefined_base_constructor_order.ts b/crates/submilli-engine/tests/fixtures/undefined_base_constructor_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_base_constructor_order.ts rename to crates/submilli-engine/tests/fixtures/undefined_base_constructor_order.ts diff --git a/crates/interpreter/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts b/crates/submilli-engine/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts rename to crates/submilli-engine/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts diff --git a/crates/interpreter/tests/fixtures/undefined_class_method_alias.ts b/crates/submilli-engine/tests/fixtures/undefined_class_method_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_class_method_alias.ts rename to crates/submilli-engine/tests/fixtures/undefined_class_method_alias.ts diff --git a/crates/interpreter/tests/fixtures/undefined_class_to_json_alias.ts b/crates/submilli-engine/tests/fixtures/undefined_class_to_json_alias.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_class_to_json_alias.ts rename to crates/submilli-engine/tests/fixtures/undefined_class_to_json_alias.ts diff --git a/crates/interpreter/tests/fixtures/undefined_closure_returns.ts b/crates/submilli-engine/tests/fixtures/undefined_closure_returns.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_closure_returns.ts rename to crates/submilli-engine/tests/fixtures/undefined_closure_returns.ts diff --git a/crates/interpreter/tests/fixtures/undefined_collections.ts b/crates/submilli-engine/tests/fixtures/undefined_collections.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_collections.ts rename to crates/submilli-engine/tests/fixtures/undefined_collections.ts diff --git a/crates/interpreter/tests/fixtures/undefined_default_parameter_write_type.ts b/crates/submilli-engine/tests/fixtures/undefined_default_parameter_write_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_default_parameter_write_type.ts rename to crates/submilli-engine/tests/fixtures/undefined_default_parameter_write_type.ts diff --git a/crates/interpreter/tests/fixtures/undefined_destructuring_defaults.ts b/crates/submilli-engine/tests/fixtures/undefined_destructuring_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_destructuring_defaults.ts rename to crates/submilli-engine/tests/fixtures/undefined_destructuring_defaults.ts diff --git a/crates/interpreter/tests/fixtures/undefined_function_optional_compatibility.ts b/crates/submilli-engine/tests/fixtures/undefined_function_optional_compatibility.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_function_optional_compatibility.ts rename to crates/submilli-engine/tests/fixtures/undefined_function_optional_compatibility.ts diff --git a/crates/interpreter/tests/fixtures/undefined_generic_union_inference.ts b/crates/submilli-engine/tests/fixtures/undefined_generic_union_inference.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_generic_union_inference.ts rename to crates/submilli-engine/tests/fixtures/undefined_generic_union_inference.ts diff --git a/crates/interpreter/tests/fixtures/undefined_inferred_parameter_defaults.ts b/crates/submilli-engine/tests/fixtures/undefined_inferred_parameter_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_inferred_parameter_defaults.ts rename to crates/submilli-engine/tests/fixtures/undefined_inferred_parameter_defaults.ts diff --git a/crates/interpreter/tests/fixtures/undefined_json.ts b/crates/submilli-engine/tests/fixtures/undefined_json.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_json.ts rename to crates/submilli-engine/tests/fixtures/undefined_json.ts diff --git a/crates/interpreter/tests/fixtures/undefined_later_destructured_parameter_capture.ts b/crates/submilli-engine/tests/fixtures/undefined_later_destructured_parameter_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_later_destructured_parameter_capture.ts rename to crates/submilli-engine/tests/fixtures/undefined_later_destructured_parameter_capture.ts diff --git a/crates/interpreter/tests/fixtures/undefined_later_inferred_default.ts b/crates/submilli-engine/tests/fixtures/undefined_later_inferred_default.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_later_inferred_default.ts rename to crates/submilli-engine/tests/fixtures/undefined_later_inferred_default.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/guards.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/guards.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/guards.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/guards.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/nullish_discriminants.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/nullish_discriminants.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/nullish_discriminants.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/nullish_discriminants.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/optional_chain.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_chain.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/optional_chain.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_chain.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/singleton_comparisons.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/singleton_comparisons.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/singleton_comparisons.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/singleton_comparisons.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts diff --git a/crates/interpreter/tests/fixtures/undefined_narrowing/typeof_void.ts b/crates/submilli-engine/tests/fixtures/undefined_narrowing/typeof_void.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_narrowing/typeof_void.ts rename to crates/submilli-engine/tests/fixtures/undefined_narrowing/typeof_void.ts diff --git a/crates/interpreter/tests/fixtures/undefined_native_optional_methods.ts b/crates/submilli-engine/tests/fixtures/undefined_native_optional_methods.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_native_optional_methods.ts rename to crates/submilli-engine/tests/fixtures/undefined_native_optional_methods.ts diff --git a/crates/interpreter/tests/fixtures/undefined_optional_method_body.ts b/crates/submilli-engine/tests/fixtures/undefined_optional_method_body.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_optional_method_body.ts rename to crates/submilli-engine/tests/fixtures/undefined_optional_method_body.ts diff --git a/crates/interpreter/tests/fixtures/undefined_optional_method_implements.ts b/crates/submilli-engine/tests/fixtures/undefined_optional_method_implements.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_optional_method_implements.ts rename to crates/submilli-engine/tests/fixtures/undefined_optional_method_implements.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_default_source_types.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_default_source_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_default_source_types.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_default_source_types.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_default_tdz.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_default_tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_default_tdz.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_default_tdz.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_defaults.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_defaults.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_defaults.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_defaults.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_destructuring_order.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_destructuring_order.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_destructuring_order.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_destructuring_order.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_pattern_capture.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_capture.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_pattern_capture.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_capture.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_pattern_literal_types.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_literal_types.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_pattern_literal_types.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_literal_types.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_pattern_write.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_write.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_pattern_write.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_write.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_property_declared_type.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_property_declared_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_property_declared_type.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_property_declared_type.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_property_inferred_type.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_property_inferred_type.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_property_inferred_type.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_property_inferred_type.ts diff --git a/crates/interpreter/tests/fixtures/undefined_parameter_tdz.ts b/crates/submilli-engine/tests/fixtures/undefined_parameter_tdz.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_parameter_tdz.ts rename to crates/submilli-engine/tests/fixtures/undefined_parameter_tdz.ts diff --git a/crates/interpreter/tests/fixtures/undefined_return_completion.ts b/crates/submilli-engine/tests/fixtures/undefined_return_completion.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_return_completion.ts rename to crates/submilli-engine/tests/fixtures/undefined_return_completion.ts diff --git a/crates/interpreter/tests/fixtures/undefined_runtime.ts b/crates/submilli-engine/tests/fixtures/undefined_runtime.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_runtime.ts rename to crates/submilli-engine/tests/fixtures/undefined_runtime.ts diff --git a/crates/interpreter/tests/fixtures/undefined_strings.ts b/crates/submilli-engine/tests/fixtures/undefined_strings.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_strings.ts rename to crates/submilli-engine/tests/fixtures/undefined_strings.ts diff --git a/crates/interpreter/tests/fixtures/undefined_temporal.ts b/crates/submilli-engine/tests/fixtures/undefined_temporal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_temporal.ts rename to crates/submilli-engine/tests/fixtures/undefined_temporal.ts diff --git a/crates/interpreter/tests/fixtures/undefined_tuple_spread.ts b/crates/submilli-engine/tests/fixtures/undefined_tuple_spread.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_tuple_spread.ts rename to crates/submilli-engine/tests/fixtures/undefined_tuple_spread.ts diff --git a/crates/interpreter/tests/fixtures/undefined_tuple_union.ts b/crates/submilli-engine/tests/fixtures/undefined_tuple_union.ts similarity index 100% rename from crates/interpreter/tests/fixtures/undefined_tuple_union.ts rename to crates/submilli-engine/tests/fixtures/undefined_tuple_union.ts diff --git a/crates/interpreter/tests/fixtures/unicode_whitespace_and_slash_escape.ts b/crates/submilli-engine/tests/fixtures/unicode_whitespace_and_slash_escape.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unicode_whitespace_and_slash_escape.ts rename to crates/submilli-engine/tests/fixtures/unicode_whitespace_and_slash_escape.ts diff --git a/crates/interpreter/tests/fixtures/union_cross_type_eq.subm b/crates/submilli-engine/tests/fixtures/union_cross_type_eq.subm similarity index 100% rename from crates/interpreter/tests/fixtures/union_cross_type_eq.subm rename to crates/submilli-engine/tests/fixtures/union_cross_type_eq.subm diff --git a/crates/interpreter/tests/fixtures/union_field_write_named_fix_round_trip.ts b/crates/submilli-engine/tests/fixtures/union_field_write_named_fix_round_trip.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_field_write_named_fix_round_trip.ts rename to crates/submilli-engine/tests/fixtures/union_field_write_named_fix_round_trip.ts diff --git a/crates/interpreter/tests/fixtures/union_field_write_names_the_fix.ts b/crates/submilli-engine/tests/fixtures/union_field_write_names_the_fix.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_field_write_names_the_fix.ts rename to crates/submilli-engine/tests/fixtures/union_field_write_names_the_fix.ts diff --git a/crates/interpreter/tests/fixtures/union_field_write_names_the_narrowing.ts b/crates/submilli-engine/tests/fixtures/union_field_write_names_the_narrowing.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_field_write_names_the_narrowing.ts rename to crates/submilli-engine/tests/fixtures/union_field_write_names_the_narrowing.ts diff --git a/crates/interpreter/tests/fixtures/union_field_write_non_union_receiver.ts b/crates/submilli-engine/tests/fixtures/union_field_write_non_union_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_field_write_non_union_receiver.ts rename to crates/submilli-engine/tests/fixtures/union_field_write_non_union_receiver.ts diff --git a/crates/interpreter/tests/fixtures/union_field_write_unnarrowable_receiver.ts b/crates/submilli-engine/tests/fixtures/union_field_write_unnarrowable_receiver.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_field_write_unnarrowable_receiver.ts rename to crates/submilli-engine/tests/fixtures/union_field_write_unnarrowable_receiver.ts diff --git a/crates/interpreter/tests/fixtures/union_literal_known_fields.ts b/crates/submilli-engine/tests/fixtures/union_literal_known_fields.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_literal_known_fields.ts rename to crates/submilli-engine/tests/fixtures/union_literal_known_fields.ts diff --git a/crates/interpreter/tests/fixtures/union_member_lowering_nullability.ts b/crates/submilli-engine/tests/fixtures/union_member_lowering_nullability.ts similarity index 100% rename from crates/interpreter/tests/fixtures/union_member_lowering_nullability.ts rename to crates/submilli-engine/tests/fixtures/union_member_lowering_nullability.ts diff --git a/crates/interpreter/tests/fixtures/union_primitive_eq.subm b/crates/submilli-engine/tests/fixtures/union_primitive_eq.subm similarity index 100% rename from crates/interpreter/tests/fixtures/union_primitive_eq.subm rename to crates/submilli-engine/tests/fixtures/union_primitive_eq.subm diff --git a/crates/interpreter/tests/fixtures/unknown/array_isarray.subm b/crates/submilli-engine/tests/fixtures/unknown/array_isarray.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/array_isarray.subm rename to crates/submilli-engine/tests/fixtures/unknown/array_isarray.subm diff --git a/crates/interpreter/tests/fixtures/unknown/array_isarray_null.subm b/crates/submilli-engine/tests/fixtures/unknown/array_isarray_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/array_isarray_null.subm rename to crates/submilli-engine/tests/fixtures/unknown/array_isarray_null.subm diff --git a/crates/interpreter/tests/fixtures/unknown/array_isarray_null_runtime.subm b/crates/submilli-engine/tests/fixtures/unknown/array_isarray_null_runtime.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/array_isarray_null_runtime.subm rename to crates/submilli-engine/tests/fixtures/unknown/array_isarray_null_runtime.subm diff --git a/crates/interpreter/tests/fixtures/unknown/closure_returns_null.subm b/crates/submilli-engine/tests/fixtures/unknown/closure_returns_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/closure_returns_null.subm rename to crates/submilli-engine/tests/fixtures/unknown/closure_returns_null.subm diff --git a/crates/interpreter/tests/fixtures/unknown/contextual_closure_returns_unknown.ts b/crates/submilli-engine/tests/fixtures/unknown/contextual_closure_returns_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/contextual_closure_returns_unknown.ts rename to crates/submilli-engine/tests/fixtures/unknown/contextual_closure_returns_unknown.ts diff --git a/crates/interpreter/tests/fixtures/unknown/eq_literal.ts b/crates/submilli-engine/tests/fixtures/unknown/eq_literal.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/eq_literal.ts rename to crates/submilli-engine/tests/fixtures/unknown/eq_literal.ts diff --git a/crates/interpreter/tests/fixtures/unknown/eq_null.subm b/crates/submilli-engine/tests/fixtures/unknown/eq_null.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/eq_null.subm rename to crates/submilli-engine/tests/fixtures/unknown/eq_null.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_and_or.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_and_or.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_and_or.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_and_or.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_arithmetic.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_arithmetic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_arithmetic.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_arithmetic.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_body_never_returns.ts b/crates/submilli-engine/tests/fixtures/unknown/expect_error_body_never_returns.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_body_never_returns.ts rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_body_never_returns.ts diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_call.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_call.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_call.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_call.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_field_access.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_field_access.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_field_access.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_field_access.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_index_access.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_index_access.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_index_access.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_index_access.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts b/crates/submilli-engine/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_ordering.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_ordering.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_ordering.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_ordering.subm diff --git a/crates/interpreter/tests/fixtures/unknown/expect_error_truthiness.subm b/crates/submilli-engine/tests/fixtures/unknown/expect_error_truthiness.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/expect_error_truthiness.subm rename to crates/submilli-engine/tests/fixtures/unknown/expect_error_truthiness.subm diff --git a/crates/interpreter/tests/fixtures/unknown/generic_null_arg.subm b/crates/submilli-engine/tests/fixtures/unknown/generic_null_arg.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/generic_null_arg.subm rename to crates/submilli-engine/tests/fixtures/unknown/generic_null_arg.subm diff --git a/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/app/main.ts b/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/app/main.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/no_value_cross_package/app/main.ts rename to crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/app/main.ts diff --git a/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts b/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts rename to crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts diff --git a/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/packages.manifest b/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/packages.manifest similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/no_value_cross_package/packages.manifest rename to crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/packages.manifest diff --git a/crates/interpreter/tests/fixtures/unknown/no_value_returns_null.ts b/crates/submilli-engine/tests/fixtures/unknown/no_value_returns_null.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/no_value_returns_null.ts rename to crates/submilli-engine/tests/fixtures/unknown/no_value_returns_null.ts diff --git a/crates/interpreter/tests/fixtures/unknown/null_into_unknown.subm b/crates/submilli-engine/tests/fixtures/unknown/null_into_unknown.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/null_into_unknown.subm rename to crates/submilli-engine/tests/fixtures/unknown/null_into_unknown.subm diff --git a/crates/interpreter/tests/fixtures/unknown/parameter_round_trip.subm b/crates/submilli-engine/tests/fixtures/unknown/parameter_round_trip.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/parameter_round_trip.subm rename to crates/submilli-engine/tests/fixtures/unknown/parameter_round_trip.subm diff --git a/crates/interpreter/tests/fixtures/unknown/short_circuit.subm b/crates/submilli-engine/tests/fixtures/unknown/short_circuit.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/short_circuit.subm rename to crates/submilli-engine/tests/fixtures/unknown/short_circuit.subm diff --git a/crates/interpreter/tests/fixtures/unknown/tostring.subm b/crates/submilli-engine/tests/fixtures/unknown/tostring.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/tostring.subm rename to crates/submilli-engine/tests/fixtures/unknown/tostring.subm diff --git a/crates/interpreter/tests/fixtures/unknown/typeof_narrowing.subm b/crates/submilli-engine/tests/fixtures/unknown/typeof_narrowing.subm similarity index 100% rename from crates/interpreter/tests/fixtures/unknown/typeof_narrowing.subm rename to crates/submilli-engine/tests/fixtures/unknown/typeof_narrowing.subm diff --git a/crates/interpreter/tests/fixtures/unknown_array_null_element.ts b/crates/submilli-engine/tests/fixtures/unknown_array_null_element.ts similarity index 100% rename from crates/interpreter/tests/fixtures/unknown_array_null_element.ts rename to crates/submilli-engine/tests/fixtures/unknown_array_null_element.ts diff --git a/crates/interpreter/tests/fixtures/uri_encode_decode.subm b/crates/submilli-engine/tests/fixtures/uri_encode_decode.subm similarity index 100% rename from crates/interpreter/tests/fixtures/uri_encode_decode.subm rename to crates/submilli-engine/tests/fixtures/uri_encode_decode.subm diff --git a/crates/interpreter/tests/fixtures/uri_error_builtin.ts b/crates/submilli-engine/tests/fixtures/uri_error_builtin.ts similarity index 100% rename from crates/interpreter/tests/fixtures/uri_error_builtin.ts rename to crates/submilli-engine/tests/fixtures/uri_error_builtin.ts diff --git a/crates/interpreter/tests/fixtures/url/build_basic.subm b/crates/submilli-engine/tests/fixtures/url/build_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/build_basic.subm rename to crates/submilli-engine/tests/fixtures/url/build_basic.subm diff --git a/crates/interpreter/tests/fixtures/url/build_host_only.ts b/crates/submilli-engine/tests/fixtures/url/build_host_only.ts similarity index 100% rename from crates/interpreter/tests/fixtures/url/build_host_only.ts rename to crates/submilli-engine/tests/fixtures/url/build_host_only.ts diff --git a/crates/interpreter/tests/fixtures/url/encode_decode_component.subm b/crates/submilli-engine/tests/fixtures/url/encode_decode_component.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/encode_decode_component.subm rename to crates/submilli-engine/tests/fixtures/url/encode_decode_component.subm diff --git a/crates/interpreter/tests/fixtures/url/encode_decode_query.subm b/crates/submilli-engine/tests/fixtures/url/encode_decode_query.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/encode_decode_query.subm rename to crates/submilli-engine/tests/fixtures/url/encode_decode_query.subm diff --git a/crates/interpreter/tests/fixtures/url/field_narrowing_guard.ts b/crates/submilli-engine/tests/fixtures/url/field_narrowing_guard.ts similarity index 100% rename from crates/interpreter/tests/fixtures/url/field_narrowing_guard.ts rename to crates/submilli-engine/tests/fixtures/url/field_narrowing_guard.ts diff --git a/crates/interpreter/tests/fixtures/url/parse_basic.subm b/crates/submilli-engine/tests/fixtures/url/parse_basic.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_basic.subm rename to crates/submilli-engine/tests/fixtures/url/parse_basic.subm diff --git a/crates/interpreter/tests/fixtures/url/parse_empty_query.subm b/crates/submilli-engine/tests/fixtures/url/parse_empty_query.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_empty_query.subm rename to crates/submilli-engine/tests/fixtures/url/parse_empty_query.subm diff --git a/crates/interpreter/tests/fixtures/url/parse_host_trailing_dot.ts b/crates/submilli-engine/tests/fixtures/url/parse_host_trailing_dot.ts similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_host_trailing_dot.ts rename to crates/submilli-engine/tests/fixtures/url/parse_host_trailing_dot.ts diff --git a/crates/interpreter/tests/fixtures/url/parse_invalid_type_error.ts b/crates/submilli-engine/tests/fixtures/url/parse_invalid_type_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_invalid_type_error.ts rename to crates/submilli-engine/tests/fixtures/url/parse_invalid_type_error.ts diff --git a/crates/interpreter/tests/fixtures/url/parse_no_fragment.subm b/crates/submilli-engine/tests/fixtures/url/parse_no_fragment.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_no_fragment.subm rename to crates/submilli-engine/tests/fixtures/url/parse_no_fragment.subm diff --git a/crates/interpreter/tests/fixtures/url/parse_no_port.subm b/crates/submilli-engine/tests/fixtures/url/parse_no_port.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_no_port.subm rename to crates/submilli-engine/tests/fixtures/url/parse_no_port.subm diff --git a/crates/interpreter/tests/fixtures/url/parse_query_encoded.subm b/crates/submilli-engine/tests/fixtures/url/parse_query_encoded.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_query_encoded.subm rename to crates/submilli-engine/tests/fixtures/url/parse_query_encoded.subm diff --git a/crates/interpreter/tests/fixtures/url/parse_query_multiple.subm b/crates/submilli-engine/tests/fixtures/url/parse_query_multiple.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/parse_query_multiple.subm rename to crates/submilli-engine/tests/fixtures/url/parse_query_multiple.subm diff --git a/crates/interpreter/tests/fixtures/url/query_type_alias.subm b/crates/submilli-engine/tests/fixtures/url/query_type_alias.subm similarity index 100% rename from crates/interpreter/tests/fixtures/url/query_type_alias.subm rename to crates/submilli-engine/tests/fixtures/url/query_type_alias.subm diff --git a/crates/interpreter/tests/fixtures/void_accessor_nested_value.ts b/crates/submilli-engine/tests/fixtures/void_accessor_nested_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_accessor_nested_value.ts rename to crates/submilli-engine/tests/fixtures/void_accessor_nested_value.ts diff --git a/crates/interpreter/tests/fixtures/void_array_element_generic_value.ts b/crates/submilli-engine/tests/fixtures/void_array_element_generic_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_array_element_generic_value.ts rename to crates/submilli-engine/tests/fixtures/void_array_element_generic_value.ts diff --git a/crates/interpreter/tests/fixtures/void_array_element_shorthand_value.ts b/crates/submilli-engine/tests/fixtures/void_array_element_shorthand_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_array_element_shorthand_value.ts rename to crates/submilli-engine/tests/fixtures/void_array_element_shorthand_value.ts diff --git a/crates/interpreter/tests/fixtures/void_as_generic_arg_value.ts b/crates/submilli-engine/tests/fixtures/void_as_generic_arg_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_as_generic_arg_value.ts rename to crates/submilli-engine/tests/fixtures/void_as_generic_arg_value.ts diff --git a/crates/interpreter/tests/fixtures/void_behind_warning_value.ts b/crates/submilli-engine/tests/fixtures/void_behind_warning_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_behind_warning_value.ts rename to crates/submilli-engine/tests/fixtures/void_behind_warning_value.ts diff --git a/crates/interpreter/tests/fixtures/void_class_field_value.ts b/crates/submilli-engine/tests/fixtures/void_class_field_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_class_field_value.ts rename to crates/submilli-engine/tests/fixtures/void_class_field_value.ts diff --git a/crates/interpreter/tests/fixtures/void_class_static_field_value.ts b/crates/submilli-engine/tests/fixtures/void_class_static_field_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_class_static_field_value.ts rename to crates/submilli-engine/tests/fixtures/void_class_static_field_value.ts diff --git a/crates/interpreter/tests/fixtures/void_closure_param_value.ts b/crates/submilli-engine/tests/fixtures/void_closure_param_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_closure_param_value.ts rename to crates/submilli-engine/tests/fixtures/void_closure_param_value.ts diff --git a/crates/interpreter/tests/fixtures/void_conditional_cast_and_json_value.ts b/crates/submilli-engine/tests/fixtures/void_conditional_cast_and_json_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_conditional_cast_and_json_value.ts rename to crates/submilli-engine/tests/fixtures/void_conditional_cast_and_json_value.ts diff --git a/crates/interpreter/tests/fixtures/void_conditional_in_comparisons_value.ts b/crates/submilli-engine/tests/fixtures/void_conditional_in_comparisons_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_conditional_in_comparisons_value.ts rename to crates/submilli-engine/tests/fixtures/void_conditional_in_comparisons_value.ts diff --git a/crates/interpreter/tests/fixtures/void_equality_value.ts b/crates/submilli-engine/tests/fixtures/void_equality_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_equality_value.ts rename to crates/submilli-engine/tests/fixtures/void_equality_value.ts diff --git a/crates/interpreter/tests/fixtures/void_function_param_value.ts b/crates/submilli-engine/tests/fixtures/void_function_param_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_function_param_value.ts rename to crates/submilli-engine/tests/fixtures/void_function_param_value.ts diff --git a/crates/interpreter/tests/fixtures/void_function_type_alias_param_value.ts b/crates/submilli-engine/tests/fixtures/void_function_type_alias_param_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_function_type_alias_param_value.ts rename to crates/submilli-engine/tests/fixtures/void_function_type_alias_param_value.ts diff --git a/crates/interpreter/tests/fixtures/void_function_type_param_value.ts b/crates/submilli-engine/tests/fixtures/void_function_type_param_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_function_type_param_value.ts rename to crates/submilli-engine/tests/fixtures/void_function_type_param_value.ts diff --git a/crates/interpreter/tests/fixtures/void_hint_diverging_closure.ts b/crates/submilli-engine/tests/fixtures/void_hint_diverging_closure.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_hint_diverging_closure.ts rename to crates/submilli-engine/tests/fixtures/void_hint_diverging_closure.ts diff --git a/crates/interpreter/tests/fixtures/void_inferred_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_inferred_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_inferred_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_inferred_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_interface_method_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_interface_method_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_interface_method_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_interface_method_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_interface_property_value.ts b/crates/submilli-engine/tests/fixtures/void_interface_property_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_interface_property_value.ts rename to crates/submilli-engine/tests/fixtures/void_interface_property_value.ts diff --git a/crates/interpreter/tests/fixtures/void_interface_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_interface_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_interface_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_interface_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_into_value_slot_value.ts b/crates/submilli-engine/tests/fixtures/void_into_value_slot_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_into_value_slot_value.ts rename to crates/submilli-engine/tests/fixtures/void_into_value_slot_value.ts diff --git a/crates/interpreter/tests/fixtures/void_literal_element_value.ts b/crates/submilli-engine/tests/fixtures/void_literal_element_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_literal_element_value.ts rename to crates/submilli-engine/tests/fixtures/void_literal_element_value.ts diff --git a/crates/interpreter/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts b/crates/submilli-engine/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts rename to crates/submilli-engine/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts diff --git a/crates/interpreter/tests/fixtures/void_nullish_left_value.ts b/crates/submilli-engine/tests/fixtures/void_nullish_left_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_nullish_left_value.ts rename to crates/submilli-engine/tests/fixtures/void_nullish_left_value.ts diff --git a/crates/interpreter/tests/fixtures/void_object_field_type_value.ts b/crates/submilli-engine/tests/fixtures/void_object_field_type_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_object_field_type_value.ts rename to crates/submilli-engine/tests/fixtures/void_object_field_type_value.ts diff --git a/crates/interpreter/tests/fixtures/void_recursive_interface_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_recursive_interface_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_recursive_interface_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_recursive_interface_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_recursive_permutation_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_recursive_permutation_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_recursive_permutation_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_recursive_permutation_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_return_position.ts b/crates/submilli-engine/tests/fixtures/void_return_position.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_return_position.ts rename to crates/submilli-engine/tests/fixtures/void_return_position.ts diff --git a/crates/interpreter/tests/fixtures/void_return_type_argument.ts b/crates/submilli-engine/tests/fixtures/void_return_type_argument.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_return_type_argument.ts rename to crates/submilli-engine/tests/fixtures/void_return_type_argument.ts diff --git a/crates/interpreter/tests/fixtures/void_setter_param_value.ts b/crates/submilli-engine/tests/fixtures/void_setter_param_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_setter_param_value.ts rename to crates/submilli-engine/tests/fixtures/void_setter_param_value.ts diff --git a/crates/interpreter/tests/fixtures/void_switch_discriminant_value.ts b/crates/submilli-engine/tests/fixtures/void_switch_discriminant_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_switch_discriminant_value.ts rename to crates/submilli-engine/tests/fixtures/void_switch_discriminant_value.ts diff --git a/crates/interpreter/tests/fixtures/void_tuple_element_value.ts b/crates/submilli-engine/tests/fixtures/void_tuple_element_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_tuple_element_value.ts rename to crates/submilli-engine/tests/fixtures/void_tuple_element_value.ts diff --git a/crates/interpreter/tests/fixtures/void_union_condition.ts b/crates/submilli-engine/tests/fixtures/void_union_condition.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_union_condition.ts rename to crates/submilli-engine/tests/fixtures/void_union_condition.ts diff --git a/crates/interpreter/tests/fixtures/void_union_member_value.ts b/crates/submilli-engine/tests/fixtures/void_union_member_value.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_union_member_value.ts rename to crates/submilli-engine/tests/fixtures/void_union_member_value.ts diff --git a/crates/interpreter/tests/fixtures/void_value_annotations.ts b/crates/submilli-engine/tests/fixtures/void_value_annotations.ts similarity index 100% rename from crates/interpreter/tests/fixtures/void_value_annotations.ts rename to crates/submilli-engine/tests/fixtures/void_value_annotations.ts diff --git a/crates/interpreter/tests/fixtures/weak_type_shared_field.ts b/crates/submilli-engine/tests/fixtures/weak_type_shared_field.ts similarity index 100% rename from crates/interpreter/tests/fixtures/weak_type_shared_field.ts rename to crates/submilli-engine/tests/fixtures/weak_type_shared_field.ts diff --git a/crates/interpreter/tests/git_memory.rs b/crates/submilli-engine/tests/git_memory.rs similarity index 100% rename from crates/interpreter/tests/git_memory.rs rename to crates/submilli-engine/tests/git_memory.rs diff --git a/crates/interpreter/tests/host_memory.rs b/crates/submilli-engine/tests/host_memory.rs similarity index 100% rename from crates/interpreter/tests/host_memory.rs rename to crates/submilli-engine/tests/host_memory.rs diff --git a/crates/interpreter/tests/http_live.rs b/crates/submilli-engine/tests/http_live.rs similarity index 100% rename from crates/interpreter/tests/http_live.rs rename to crates/submilli-engine/tests/http_live.rs diff --git a/crates/interpreter/tests/http_live_fixtures/download_basic.subm b/crates/submilli-engine/tests/http_live_fixtures/download_basic.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/download_basic.subm rename to crates/submilli-engine/tests/http_live_fixtures/download_basic.subm diff --git a/crates/interpreter/tests/http_live_fixtures/download_gzip_decompress.subm b/crates/submilli-engine/tests/http_live_fixtures/download_gzip_decompress.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/download_gzip_decompress.subm rename to crates/submilli-engine/tests/http_live_fixtures/download_gzip_decompress.subm diff --git a/crates/interpreter/tests/http_live_fixtures/get_200_body.subm b/crates/submilli-engine/tests/http_live_fixtures/get_200_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/get_200_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/get_200_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/get_404.subm b/crates/submilli-engine/tests/http_live_fixtures/get_404.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/get_404.subm rename to crates/submilli-engine/tests/http_live_fixtures/get_404.subm diff --git a/crates/interpreter/tests/http_live_fixtures/headers_authorization.subm b/crates/submilli-engine/tests/http_live_fixtures/headers_authorization.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/headers_authorization.subm rename to crates/submilli-engine/tests/http_live_fixtures/headers_authorization.subm diff --git a/crates/interpreter/tests/http_live_fixtures/headers_missing_auth_returns_404.subm b/crates/submilli-engine/tests/http_live_fixtures/headers_missing_auth_returns_404.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/headers_missing_auth_returns_404.subm rename to crates/submilli-engine/tests/http_live_fixtures/headers_missing_auth_returns_404.subm diff --git a/crates/interpreter/tests/http_live_fixtures/json_body.subm b/crates/submilli-engine/tests/http_live_fixtures/json_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/json_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/json_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/json_method.subm b/crates/submilli-engine/tests/http_live_fixtures/json_method.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/json_method.subm rename to crates/submilli-engine/tests/http_live_fixtures/json_method.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_array_body.subm b/crates/submilli-engine/tests/http_live_fixtures/post_array_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_array_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_array_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_null_body.subm b/crates/submilli-engine/tests/http_live_fixtures/post_null_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_null_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_null_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_object_body.subm b/crates/submilli-engine/tests/http_live_fixtures/post_object_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_object_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_object_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_object_body_custom_ct.subm b/crates/submilli-engine/tests/http_live_fixtures/post_object_body_custom_ct.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_object_body_custom_ct.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_object_body_custom_ct.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_string_body.subm b/crates/submilli-engine/tests/http_live_fixtures/post_string_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_string_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_string_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_uint8array_body.subm b/crates/submilli-engine/tests/http_live_fixtures/post_uint8array_body.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_uint8array_body.subm rename to crates/submilli-engine/tests/http_live_fixtures/post_uint8array_body.subm diff --git a/crates/interpreter/tests/http_live_fixtures/post_undefined_body.ts b/crates/submilli-engine/tests/http_live_fixtures/post_undefined_body.ts similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/post_undefined_body.ts rename to crates/submilli-engine/tests/http_live_fixtures/post_undefined_body.ts diff --git a/crates/interpreter/tests/http_live_fixtures/put_string_body_ct_override.subm b/crates/submilli-engine/tests/http_live_fixtures/put_string_body_ct_override.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/put_string_body_ct_override.subm rename to crates/submilli-engine/tests/http_live_fixtures/put_string_body_ct_override.subm diff --git a/crates/interpreter/tests/http_live_fixtures/request_runtime_verb.subm b/crates/submilli-engine/tests/http_live_fixtures/request_runtime_verb.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/request_runtime_verb.subm rename to crates/submilli-engine/tests/http_live_fixtures/request_runtime_verb.subm diff --git a/crates/interpreter/tests/http_live_fixtures/response_to_string.subm b/crates/submilli-engine/tests/http_live_fixtures/response_to_string.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/response_to_string.subm rename to crates/submilli-engine/tests/http_live_fixtures/response_to_string.subm diff --git a/crates/interpreter/tests/http_live_fixtures/verb_matrix.subm b/crates/submilli-engine/tests/http_live_fixtures/verb_matrix.subm similarity index 100% rename from crates/interpreter/tests/http_live_fixtures/verb_matrix.subm rename to crates/submilli-engine/tests/http_live_fixtures/verb_matrix.subm diff --git a/crates/interpreter/tests/http_tls_fixtures/ca.pem b/crates/submilli-engine/tests/http_tls_fixtures/ca.pem similarity index 100% rename from crates/interpreter/tests/http_tls_fixtures/ca.pem rename to crates/submilli-engine/tests/http_tls_fixtures/ca.pem diff --git a/crates/interpreter/tests/http_tls_fixtures/localhost-key.pem b/crates/submilli-engine/tests/http_tls_fixtures/localhost-key.pem similarity index 100% rename from crates/interpreter/tests/http_tls_fixtures/localhost-key.pem rename to crates/submilli-engine/tests/http_tls_fixtures/localhost-key.pem diff --git a/crates/interpreter/tests/http_tls_fixtures/localhost.pem b/crates/submilli-engine/tests/http_tls_fixtures/localhost.pem similarity index 100% rename from crates/interpreter/tests/http_tls_fixtures/localhost.pem rename to crates/submilli-engine/tests/http_tls_fixtures/localhost.pem diff --git a/crates/interpreter/tests/lexer_limits.rs b/crates/submilli-engine/tests/lexer_limits.rs similarity index 100% rename from crates/interpreter/tests/lexer_limits.rs rename to crates/submilli-engine/tests/lexer_limits.rs diff --git a/crates/interpreter/tests/memory_caps.rs b/crates/submilli-engine/tests/memory_caps.rs similarity index 100% rename from crates/interpreter/tests/memory_caps.rs rename to crates/submilli-engine/tests/memory_caps.rs diff --git a/crates/interpreter/tests/namespace_limits.rs b/crates/submilli-engine/tests/namespace_limits.rs similarity index 100% rename from crates/interpreter/tests/namespace_limits.rs rename to crates/submilli-engine/tests/namespace_limits.rs diff --git a/crates/interpreter/tests/object_vtable_dispatch.rs b/crates/submilli-engine/tests/object_vtable_dispatch.rs similarity index 100% rename from crates/interpreter/tests/object_vtable_dispatch.rs rename to crates/submilli-engine/tests/object_vtable_dispatch.rs diff --git a/crates/interpreter/tests/package_diagnostic_snapshots.rs b/crates/submilli-engine/tests/package_diagnostic_snapshots.rs similarity index 100% rename from crates/interpreter/tests/package_diagnostic_snapshots.rs rename to crates/submilli-engine/tests/package_diagnostic_snapshots.rs diff --git a/crates/interpreter/tests/parser_depth.rs b/crates/submilli-engine/tests/parser_depth.rs similarity index 100% rename from crates/interpreter/tests/parser_depth.rs rename to crates/submilli-engine/tests/parser_depth.rs diff --git a/crates/interpreter/tests/record_limits.rs b/crates/submilli-engine/tests/record_limits.rs similarity index 100% rename from crates/interpreter/tests/record_limits.rs rename to crates/submilli-engine/tests/record_limits.rs diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap similarity index 95% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap index c649d9982..e79bbbbd4 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 64 expression: "render_inside_main(\" let n: number = 42;\\n let r = n(1);\")" --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap similarity index 86% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap index 7c1d53baf..a7ac199d0 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 74 expression: "render_inside_main(\" let o = { a: 1 };\\n let k = \\\"a\\\";\\n let r = o[k];\")" --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap similarity index 84% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap index c064cfc76..ee454486c 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let p: { x: number; y: number } = { x: 1, y: 2 };\\n let z = p.z;\")" --- error: field `z` does not exist on `{ x: number; y: number }` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap similarity index 95% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap index 5332ff8c6..2ce896134 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 69 expression: "render_inside_main(\" let n: number = 42;\\n let r = n[0];\")" --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap similarity index 78% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap index 7a1453856..a6eb43f53 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected 2 argument(s), got 1 diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap similarity index 93% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap index e9b8ae59e..0036143db 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: object literal has unknown field `z` for the target type diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap similarity index 92% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap index 11afc1abf..6d89a3570 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n let ys = xs.map((x: number) => x.toString());\")" --- error: method `map` expects 1 type argument(s), got 2 diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap similarity index 90% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap index c59b5b998..0f6f0663a 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" parseInt();\")" --- error: expected 1-2 argument(s), got 0 diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap similarity index 87% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap index b9edf1232..d204e1403 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n xs.push();\")" --- error: method `push` expects 1 argument(s), got 0 diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap similarity index 79% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap index 3af023b70..a451441be 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let x = Number(42);\")" --- error: expected `string | bigint | undefined`, got `number` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap similarity index 79% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap index 6a1292e13..d0bc79a28 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let n: numbre = 1;\")" --- error: unknown type `numbre` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap similarity index 83% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap index 30c0922f4..1b486e632 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let pi: number = 3;\\n let q = absolutely_unrelated_name;\")" --- error: unresolved identifier `absolutely_unrelated_name` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap similarity index 80% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap index 1354b9a0e..b1eb50707 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let pi: number = 3;\\n let q = pi2;\")" --- error: unresolved identifier `pi2` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap similarity index 78% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap index f7a523258..fcee0bf57 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `T`, got `null` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap similarity index 80% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap index a15cf72a4..a4b20e150 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const x: number;\")" --- error: `const` declaration requires an initializer diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap similarity index 88% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap index d83ff3bb8..bbc568789 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\"const k: number = 1;\\nfunction main(): void { k = 2; }\\n\")" --- error: cannot assign to const binding `k` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap similarity index 86% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap index 9ef30821b..067482627 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const k = 1;\\n k = 2;\")" --- error: cannot assign to const binding `k` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap similarity index 85% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap index ae963cefc..e68e42655 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\"function f(): void { }\\nfunction main(): void { f = 1; }\\n\")" --- error: cannot assign to function `f` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap similarity index 86% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap index 2aa1d9664..044d66c56 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 151 expression: "render_inside_main(\" let x: number;\")" --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap similarity index 74% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap index ffae592f4..3b2d9cb58 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\" \\n\")" --- error: missing `main` function diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap similarity index 77% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap index 04941fad2..d57d03a66 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\"function main() { }\\n\")" --- error: expected `:` and return type diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap similarity index 89% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap index da2a3766d..267635bea 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\"function f(a): number { return a; }\\nfunction main(): void { }\\n\")" --- error: parameter requires a type annotation diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap similarity index 82% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap index bb7c875f0..aea8310d7 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_all(\"function main(): void { }\\nreturn 1;\\n\")" --- error: `return` outside function diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap similarity index 82% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap index b98777678..d3f38041c 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let s = \\\"hi\\\\q\\\";\")" --- error: unknown escape sequence `\q` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap similarity index 94% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap index 65b834486..9f05d9e8c 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `number`, got `boolean` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap similarity index 94% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap index 6c5162db3..14013ddb3 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 235 expression: render_all(source) --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap similarity index 87% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap index d831994d6..e631117e1 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const g = (x: string) => true;\\n let f: (a: number, b: number) => boolean = g;\")" --- error: expected `(arg0: number, arg1: number) => boolean`, got `(arg0: string) => boolean` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap similarity index 92% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap index 2b981b3ee..c0172aec4 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 225 expression: render_all(source) --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap similarity index 78% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap index 0479ea612..49aca98fa 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `string`, got `number` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap similarity index 82% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap index 890220845..9937ba022 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: duplicate `@param a` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap similarity index 80% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap index 1282d6dec..fdc21b010 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: missing `@returns` on a non-`void`-returning function diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap similarity index 88% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap index 18556d64b..c6ed4c17f 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@param wrong` does not match any parameter of this function diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap similarity index 79% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap index 7a364259f..b6a30cee5 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@param wrong` on a property — properties have no parameters diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap similarity index 75% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap index 4d3772533..d7e40919f 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@returns` on a `void`-returning function diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap similarity index 84% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap index 5e527286c..9e19da547 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected 2 argument(s), got 1 diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap similarity index 85% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap index bf76e11a8..7888937a0 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: parameter `a` is undocumented (missing `@param a`) diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap similarity index 86% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap index 8cd24fb9c..1024507b4 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: duplicate `catch` clause for `ParseError` diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap similarity index 89% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap index 4b81fe855..e712953d1 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: unreachable `catch` clause: `Derived` extends `Base`, which an earlier clause already catches diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap similarity index 90% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap index 747b9d681..8d4385af7 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs assertion_line: 404 expression: "render_inside_main(\" const n = null;\\n let s = n.toString();\")" --- diff --git a/crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap similarity index 87% rename from crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap rename to crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap index b9edf1232..d204e1403 100644 --- a/crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap +++ b/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/diagnostic_snapshots.rs +source: crates/submilli-engine/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n xs.push();\")" --- error: method `push` expects 1 argument(s), got 0 diff --git a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap similarity index 94% rename from crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap rename to crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap index 4b5f06e61..8f6b6f28a 100644 --- a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap +++ b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/package_diagnostic_snapshots.rs +source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\nfunction deliver(input: Input): void {}\n\n/**\n * Sends the message.\n * @param input Message and where to send it.\n * @capability test.com/send { channelId: string }\n */\nexport function send(input: Input): void {\n const channelId = input.channelId;\n check(\\\"test.com/send\\\", { channelId: channelId });\n deliver(input);\n deliver(input);\n}\n\")" --- warning: caller-supplied `input` is passed to `deliver` in `send`, which calls `check()` (and 1 more) diff --git a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap similarity index 94% rename from crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap rename to crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap index 6ce834052..c241e42ac 100644 --- a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap +++ b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/package_diagnostic_snapshots.rs +source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\n/**\n * Approves the send.\n * @param channelId Conversation to post in.\n * @capability test.com/send { channelId: string }\n */\nfunction guard(channelId: string): void {\n check(\\\"test.com/send\\\", { channelId: channelId });\n}\n\n/**\n * Sends the message.\n * @param channelId Conversation to post in.\n * @param text Message text.\n */\nexport function send(channelId: string, text: string): void {\n guard(channelId);\n post(channelId, text);\n}\n\")" --- warning: `check()` is called in `guard`, which is not part of the package's public API diff --git a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap similarity index 95% rename from crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap rename to crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap index 8eada2ed9..0bd0ff2fd 100644 --- a/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap +++ b/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap @@ -1,5 +1,5 @@ --- -source: crates/interpreter/tests/package_diagnostic_snapshots.rs +source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\n/**\n * Sends the message.\n * @param input Message and where to send it.\n * @capability test.com/send { channelId: string }\n */\nexport function send(input: Input): void {\n check(\\\"test.com/send\\\", { channelId: input.channelId });\n post(input.channelId, \\\"hello\\\");\n}\n\")" --- warning: `input.channelId` is read more than once in `send`, which calls `check()` diff --git a/crates/interpreter/tests/substitution_limits.rs b/crates/submilli-engine/tests/substitution_limits.rs similarity index 100% rename from crates/interpreter/tests/substitution_limits.rs rename to crates/submilli-engine/tests/substitution_limits.rs diff --git a/crates/interpreter/tests/traps_in_callbacks.rs b/crates/submilli-engine/tests/traps_in_callbacks.rs similarity index 100% rename from crates/interpreter/tests/traps_in_callbacks.rs rename to crates/submilli-engine/tests/traps_in_callbacks.rs diff --git a/crates/interpreter/tests/type_limits.rs b/crates/submilli-engine/tests/type_limits.rs similarity index 100% rename from crates/interpreter/tests/type_limits.rs rename to crates/submilli-engine/tests/type_limits.rs diff --git a/crates/interpreter/tests/vfs_containment.rs b/crates/submilli-engine/tests/vfs_containment.rs similarity index 100% rename from crates/interpreter/tests/vfs_containment.rs rename to crates/submilli-engine/tests/vfs_containment.rs diff --git a/crates/submilli-policy/Cargo.toml b/crates/submilli-policy/Cargo.toml index 33c3e31fb..1ad739042 100644 --- a/crates/submilli-policy/Cargo.toml +++ b/crates/submilli-policy/Cargo.toml @@ -22,7 +22,7 @@ serde_json = { workspace = true } regex = { workspace = true } async-trait = { workspace = true } base64 = { workspace = true } -submilli-engine = { version = "0.3.0", path = "../interpreter", optional = true } +submilli-engine = { version = "0.3.0", path = "../submilli-engine", optional = true } url = { workspace = true, optional = true } [features] @@ -30,5 +30,5 @@ url = { workspace = true, optional = true } engine = ["dep:submilli-engine", "dep:url"] [dev-dependencies] -submilli-engine = { path = "../interpreter" } +submilli-engine = { path = "../submilli-engine" } tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/crates/submilli-server/Cargo.toml b/crates/submilli-server/Cargo.toml index fb5c52b12..4729980f2 100644 --- a/crates/submilli-server/Cargo.toml +++ b/crates/submilli-server/Cargo.toml @@ -17,7 +17,7 @@ path = "src/main.rs" path = "src/lib.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../submilli-engine" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } diff --git a/crates/submilli-shared/Cargo.toml b/crates/submilli-shared/Cargo.toml index cca220dac..1d866b15e 100644 --- a/crates/submilli-shared/Cargo.toml +++ b/crates/submilli-shared/Cargo.toml @@ -13,7 +13,7 @@ workspace = true path = "src/lib.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../submilli-engine" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-policy = { path = "../submilli-policy", features = ["engine"] } submilli-build = { path = "../submilli-build" } diff --git a/crates/submilli/Cargo.toml b/crates/submilli/Cargo.toml index 1a0937d16..b7573197c 100644 --- a/crates/submilli/Cargo.toml +++ b/crates/submilli/Cargo.toml @@ -14,7 +14,7 @@ name = "submilli" path = "src/main.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../interpreter" } +interpreter = { package = "submilli-engine", path = "../submilli-engine" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } diff --git a/examples/docker/conformance.ts b/examples/docker/conformance.ts index e6899d39e..f723097ae 100644 --- a/examples/docker/conformance.ts +++ b/examples/docker/conformance.ts @@ -2,7 +2,7 @@ // against a running container by scripts/docker-conformance.sh. // // It deliberately does *not* re-prove language semantics. The fixture suite in -// crates/interpreter/tests/fixtures/ already does that, and those results cannot +// crates/submilli-engine/tests/fixtures/ already does that, and those results cannot // vary by environment: same WasmGC module, same Rust host functions, same answer // on a laptop and in distroless. What can vary is the boundary where the runtime // reaches out to the operating system — TLS trust, DNS, the timezone database, From efc3d3e44a81f07ff1b1089aa7ac4ba00efd5cfa Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 19:20:03 +0300 Subject: [PATCH 08/10] Keep the engine in crates/interpreter for this change Moving the directory touches every file in the crate, which buries the reviewable change; the move follows in its own PR. The doc comment fix stays. Co-Authored-By: Claude Opus 5.5 --- AGENTS.md | 6 +++--- Cargo.toml | 2 +- crates/conformance/Cargo.toml | 2 +- crates/conformance/typescript/README.md | 2 +- crates/{submilli-engine => interpreter}/Cargo.toml | 0 crates/{submilli-engine => interpreter}/README.md | 0 crates/{submilli-engine => interpreter}/build.rs | 0 crates/{submilli-engine => interpreter}/src/arena.rs | 0 .../{submilli-engine => interpreter}/src/artifact_f64.rs | 0 crates/{submilli-engine => interpreter}/src/asi.rs | 0 crates/{submilli-engine => interpreter}/src/ast.rs | 0 crates/{submilli-engine => interpreter}/src/authority.rs | 0 crates/{submilli-engine => interpreter}/src/backtrace.rs | 0 .../src/capability_derivation.rs | 0 .../src/codegen/analysis.rs | 0 .../src/codegen/argument_defaults.rs | 0 .../src/codegen/bigint_pool.rs | 0 .../src/codegen/bounds.rs | 0 .../src/codegen/box_types.rs | 0 .../src/codegen/call_arguments.rs | 0 .../src/codegen/cast_check.rs | 0 .../src/codegen/cast_diagnostics.rs | 0 .../src/codegen/classes.rs | 0 .../src/codegen/closure_coercions.rs | 0 .../src/codegen/closures.rs | 0 .../src/codegen/dependency_usage.rs | 0 .../{submilli-engine => interpreter}/src/codegen/dwarf.rs | 0 .../src/codegen/field_guards.rs | 0 .../src/codegen/field_lookup.rs | 0 .../src/codegen/field_name_strings.rs | 0 .../src/codegen/field_names.rs | 0 .../src/codegen/function_adapters.rs | 0 .../src/codegen/function_emitter/binding_cells.rs | 0 .../src/codegen/function_emitter/cast.rs | 0 .../src/codegen/function_emitter/expr.rs | 0 .../src/codegen/function_emitter/finally.rs | 0 .../src/codegen/function_emitter/json.rs | 0 .../src/codegen/function_emitter/mcp.rs | 0 .../src/codegen/function_emitter/mod.rs | 0 .../src/codegen/function_emitter/stmt.rs | 0 .../src/codegen/imported_classes.rs | 0 .../src/codegen/init_guard.rs | 0 .../src/codegen/intrinsics.rs | 0 .../src/codegen/invariant_tests.rs | 0 .../{submilli-engine => interpreter}/src/codegen/mod.rs | 0 .../src/codegen/nullish.rs | 0 .../src/codegen/recursive_validators.rs | 0 .../src/codegen/runtime_descriptors.rs | 0 .../src/codegen/runtime_values.rs | 0 .../src/codegen/runtime_values/declarations.rs | 0 .../src/codegen/runtime_values/flow.rs | 0 .../src/codegen/runtime_values/rewrite.rs | 0 ...odegen__tests__assert_false_throws_with_backtrace.snap | 2 +- ..._method_accessor_and_constructor_frames_are_named.snap | 2 +- ...s__code_after_a_cast_keeps_its_backtrace_location.snap | 2 +- ...bmilli_engine__codegen__tests__dwarf_die_snapshot.snap | 2 +- ..._codegen__tests__dwarf_line_program_covers_helper.snap | 2 +- ...gine__codegen__tests__dwarf_line_program_snapshot.snap | 2 +- ...__tests__dwarf_subprograms_for_each_user_function.snap | 2 +- ...__tests__failed_cast_backtrace_points_at_the_cast.snap | 2 +- ...lli_engine__codegen__tests__multi_frame_backtrace.snap | 2 +- ...ts__three_frame_backtrace_labels_caller_in_middle.snap | 2 +- .../src/codegen/string_pool.rs | 0 .../src/codegen/symbol_table.rs | 0 .../src/codegen/this_binding.rs | 0 .../{submilli-engine => interpreter}/src/codegen/throw.rs | 0 .../src/codegen/user_subtypes.rs | 0 .../src/codegen/vtable_walk.rs | 0 crates/{submilli-engine => interpreter}/src/compile.rs | 0 .../src/compile_capabilities.rs | 0 .../src/compiler_error.rs | 0 .../src/compiler_limits.rs | 0 .../{submilli-engine => interpreter}/src/diagnostics.rs | 0 .../{submilli-engine => interpreter}/src/did_you_mean.rs | 0 .../{submilli-engine => interpreter}/src/doc_comment.rs | 0 crates/{submilli-engine => interpreter}/src/lexer.rs | 0 crates/{submilli-engine => interpreter}/src/lib.rs | 0 .../{submilli-engine => interpreter}/src/literal_units.rs | 0 .../src/lower_patterns.rs | 0 crates/{submilli-engine => interpreter}/src/mangle.rs | 0 .../src/package_declaration.rs | 0 crates/{submilli-engine => interpreter}/src/packages.rs | 0 crates/{submilli-engine => interpreter}/src/parser.rs | 0 crates/{submilli-engine => interpreter}/src/rendering.rs | 0 .../src/runtime/agents.rs | 0 .../src/runtime/array_storage.rs | 0 .../src/runtime/blocking.rs | 0 .../src/runtime/call_log.rs | 0 .../src/runtime/decision.rs | 0 .../src/runtime/disk_quota.rs | 0 .../src/runtime/embedding.rs | 0 .../{submilli-engine => interpreter}/src/runtime/exec.rs | 0 crates/{submilli-engine => interpreter}/src/runtime/fs.rs | 0 .../src/runtime/fs/removal.rs | 0 .../{submilli-engine => interpreter}/src/runtime/fuel.rs | 0 .../src/runtime/gc_singleton.rs | 0 .../{submilli-engine => interpreter}/src/runtime/host.rs | 0 .../src/runtime/intrinsic_types.rs | 0 .../{submilli-engine => interpreter}/src/runtime/json.rs | 0 .../src/runtime/json/format.rs | 0 .../src/runtime/json_text.rs | 0 .../src/runtime/limits.rs | 0 .../{submilli-engine => interpreter}/src/runtime/llm.rs | 0 .../{submilli-engine => interpreter}/src/runtime/mcp.rs | 0 .../src/runtime/mcp/response.rs | 0 .../src/runtime/metrics.rs | 0 .../{submilli-engine => interpreter}/src/runtime/mod.rs | 0 .../src/runtime/number.rs | 0 .../src/runtime/prelude/arguments.rs | 0 .../src/runtime/prelude/array/install.rs | 0 .../src/runtime/prelude/array/mod.rs | 0 .../src/runtime/prelude/array/sort.rs | 0 .../src/runtime/prelude/bigint/mod.rs | 0 .../src/runtime/prelude/bigint/ops.rs | 0 .../src/runtime/prelude/bitwise.rs | 0 .../src/runtime/prelude/boolean/mod.rs | 0 .../src/runtime/prelude/closure.rs | 0 .../src/runtime/prelude/collection.rs | 0 .../src/runtime/prelude/console.rs | 0 .../src/runtime/prelude/declaration.rs | 0 .../src/runtime/prelude/error.rs | 0 .../src/runtime/prelude/iterator/mod.rs | 0 .../src/runtime/prelude/keep.rs | 0 .../src/runtime/prelude/ledger.rs | 0 .../src/runtime/prelude/map/install.rs | 0 .../src/runtime/prelude/map/mod.rs | 0 .../src/runtime/prelude/math.rs | 0 .../src/runtime/prelude/member.rs | 0 .../src/runtime/prelude/mod.rs | 0 .../src/runtime/prelude/number/mod.rs | 0 .../src/runtime/prelude/object/dynamic.rs | 0 .../src/runtime/prelude/object/index.rs | 0 .../src/runtime/prelude/object/mod.rs | 0 .../src/runtime/prelude/object/static_value.rs | 0 .../src/runtime/prelude/regex/engine.rs | 0 .../src/runtime/prelude/regex/input.rs | 0 .../src/runtime/prelude/regex/install.rs | 0 .../src/runtime/prelude/regex/mod.rs | 0 .../src/runtime/prelude/regex/output.rs | 0 .../src/runtime/prelude/set/install.rs | 0 .../src/runtime/prelude/set/mod.rs | 0 .../src/runtime/prelude/string/install.rs | 0 .../src/runtime/prelude/string/mod.rs | 0 .../src/runtime/prelude/string/search.rs | 0 .../src/runtime/prelude/string/transforms.rs | 0 .../src/runtime/prelude/temporal/duration/install.rs | 0 .../src/runtime/prelude/temporal/duration/mod.rs | 0 .../src/runtime/prelude/temporal/instant/install.rs | 0 .../src/runtime/prelude/temporal/instant/mod.rs | 0 .../src/runtime/prelude/temporal/mod.rs | 0 .../src/runtime/prelude/temporal/now/install.rs | 0 .../src/runtime/prelude/temporal/now/mod.rs | 0 .../src/runtime/prelude/temporal/plain_date/install.rs | 0 .../src/runtime/prelude/temporal/plain_date/mod.rs | 0 .../runtime/prelude/temporal/plain_date_time/install.rs | 0 .../src/runtime/prelude/temporal/plain_date_time/mod.rs | 0 .../runtime/prelude/temporal/plain_month_day/install.rs | 0 .../src/runtime/prelude/temporal/plain_month_day/mod.rs | 0 .../src/runtime/prelude/temporal/plain_time/install.rs | 0 .../src/runtime/prelude/temporal/plain_time/mod.rs | 0 .../runtime/prelude/temporal/plain_year_month/install.rs | 0 .../src/runtime/prelude/temporal/plain_year_month/mod.rs | 0 .../src/runtime/prelude/temporal/shared.rs | 0 .../runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE | 0 .../runtime/prelude/temporal/zoned_date_time/install.rs | 0 .../src/runtime/prelude/temporal/zoned_date_time/mod.rs | 0 .../prelude/temporal/zoned_date_time/zone_cache.rs | 0 .../runtime/prelude/temporal/zoned_date_time/zone_ids.rs | 0 .../src/runtime/prelude/textcodec/install.rs | 0 .../src/runtime/prelude/textcodec/mod.rs | 0 .../src/runtime/prelude/uint8array/install.rs | 0 .../src/runtime/prelude/uint8array/mod.rs | 0 .../src/runtime/prelude/undefined.rs | 0 .../src/runtime/prelude/uri.rs | 0 .../src/runtime/prelude/value.rs | 0 .../src/runtime/prelude/vtable.rs | 0 .../src/runtime/prelude/vtable/serialization.rs | 0 .../src/runtime/secrets.rs | 0 .../src/runtime/security.rs | 0 .../src/runtime/session_kv.rs | 0 .../src/runtime/skills.rs | 0 .../src/runtime/token_ledger.rs | 0 .../{submilli-engine => interpreter}/src/runtime/vfs.rs | 0 .../src/runtime/watchdog.rs | 0 crates/{submilli-engine => interpreter}/src/shape.rs | 0 ...submilli_engine__asi__tests__mvp_fixture_snapshot.snap | 2 +- ..._engine__diagnostics__tests__render_clamps_at_eof.snap | 2 +- ..._engine__diagnostics__tests__render_clamps_at_sof.snap | 2 +- ...ts__render_multi_note_error_with_gutter_alignment.snap | 2 +- ..._diagnostics__tests__render_multiline_span_carets.snap | 2 +- ...engine__diagnostics__tests__render_multiple_helps.snap | 2 +- ...ine__diagnostics__tests__render_single_line_error.snap | 2 +- ...gine__diagnostics__tests__render_warning_severity.snap | 2 +- ...illi_engine__diagnostics__tests__render_with_help.snap | 2 +- ...e__diagnostics__tests__render_with_help_and_notes.snap | 2 +- ...iagnostics__tests__render_zero_length_span_at_eof.snap | 2 +- ...e__lexer__tests__renders_bare_exponent_diagnostic.snap | 2 +- ...er__tests__renders_unterminated_string_diagnostic.snap | 2 +- ...__tests__renders_unterminated_template_diagnostic.snap | 2 +- ...bmilli_engine__lexer__tests__tokenize_mvp_fixture.snap | 2 +- ...ne__parser__tests__full_precedence_chain_snapshot.snap | 2 +- ...li_engine__parser__tests__parse_sequence_of_atoms.snap | 2 +- ...lli_engine__parser__tests__snapshot_else_if_chain.snap | 2 +- ...ine__parser__tests__snapshot_function_declaration.snap | 2 +- ...rser__tests__snapshot_function_with_if_and_return.snap | 2 +- ...gine__parser__tests__snapshot_function_with_while.snap | 2 +- ...ngine__parser__tests__snapshot_mixed_declarations.snap | 2 +- ...ngine__parser__tests__snapshot_multi_call_program.snap | 2 +- ...ngine__parser__tests__snapshot_multi_error_render.snap | 2 +- ...parser__tests__snapshot_object_and_array_literals.snap | 2 +- ...li_engine__parser__tests__snapshot_union_type_mix.snap | 2 +- crates/{submilli-engine => interpreter}/src/source.rs | 0 .../src/source_validation.rs | 0 crates/{submilli-engine => interpreter}/src/span.rs | 0 crates/{submilli-engine => interpreter}/src/stdlib/abi.rs | 0 .../src/stdlib/agents/declaration.rs | 0 .../src/stdlib/agents/mod.rs | 0 .../src/stdlib/capabilities.rs | 0 .../src/stdlib/code/budget.rs | 0 .../src/stdlib/code/declaration.rs | 0 .../src/stdlib/code/mod.rs | 0 .../src/stdlib/code/myers.rs | 0 .../src/stdlib/code/patch.rs | 0 .../src/stdlib/code/tests.rs | 0 .../src/stdlib/code/text.rs | 0 .../src/stdlib/code/walk.rs | 0 .../{submilli-engine => interpreter}/src/stdlib/crypto.rs | 0 .../src/stdlib/dot_segments.rs | 0 .../src/stdlib/embedding/declaration.rs | 0 .../src/stdlib/embedding/mod.rs | 0 .../src/stdlib/fs/declaration.rs | 0 .../src/stdlib/fs/handles.rs | 0 .../{submilli-engine => interpreter}/src/stdlib/fs/mod.rs | 0 .../src/stdlib/git/class.rs | 0 .../src/stdlib/git/declaration.rs | 0 .../src/stdlib/git/diff.rs | 0 .../src/stdlib/git/history.rs | 0 .../src/stdlib/git/index_limits.rs | 0 .../src/stdlib/git/integration_tests.rs | 0 .../src/stdlib/git/location.rs | 0 .../src/stdlib/git/lock.rs | 0 .../src/stdlib/git/log_cache.rs | 0 .../src/stdlib/git/metadata_scan.rs | 0 .../src/stdlib/git/meter.rs | 0 .../src/stdlib/git/mod.rs | 0 .../src/stdlib/git/object.rs | 0 .../src/stdlib/git/operations.rs | 0 .../src/stdlib/git/pack_index_check.rs | 0 .../src/stdlib/git/pack_limits.rs | 0 .../src/stdlib/git/stage.rs | 0 .../src/stdlib/git/storage.rs | 0 .../src/stdlib/git/tests.rs | 0 .../src/stdlib/git/transport.rs | 0 .../src/stdlib/git/work.rs | 0 .../src/stdlib/git/worker.rs | 0 .../src/stdlib/http/declaration.rs | 0 .../src/stdlib/http/mod.rs | 0 .../src/stdlib/http/policy.rs | 0 .../src/stdlib/http/redirect_guard.rs | 0 .../src/stdlib/http/transport.rs | 0 .../src/stdlib/http/transport_policy.rs | 0 .../src/stdlib/http/transport_policy_tests.rs | 0 .../src/stdlib/http/transport_tls_tests.rs | 0 .../src/stdlib/llm/declaration.rs | 0 .../src/stdlib/llm/mod.rs | 0 crates/{submilli-engine => interpreter}/src/stdlib/mod.rs | 0 .../src/stdlib/optional_tests.rs | 0 .../src/stdlib/secrets.rs | 0 .../src/stdlib/security.rs | 0 .../src/stdlib/session/cursor.rs | 0 .../src/stdlib/session/declaration.rs | 0 .../src/stdlib/session/mod.rs | 0 .../src/stdlib/session/value.rs | 0 .../{submilli-engine => interpreter}/src/stdlib/shared.rs | 0 .../src/stdlib/skills/declaration.rs | 0 .../src/stdlib/skills/mod.rs | 0 .../{submilli-engine => interpreter}/src/stdlib/test.rs | 0 crates/{submilli-engine => interpreter}/src/stdlib/url.rs | 0 .../{submilli-engine => interpreter}/src/stdlib/uuid.rs | 0 crates/{submilli-engine => interpreter}/src/token.rs | 0 .../{submilli-engine => interpreter}/src/tree_height.rs | 0 crates/{submilli-engine => interpreter}/src/type_info.rs | 0 .../src/type_rendering.rs | 0 crates/{submilli-engine => interpreter}/src/type_size.rs | 0 crates/{submilli-engine => interpreter}/src/type_walk.rs | 0 .../src/typechecker/capture.rs | 0 .../src/typechecker/desugar/do_while.rs | 0 .../src/typechecker/desugar/for_loop.rs | 0 .../src/typechecker/desugar/for_of.rs | 0 .../src/typechecker/desugar/mod.rs | 0 .../src/typechecker/desugar/postfix_incdec.rs | 0 .../src/typechecker/infer/aliased_conditions.rs | 0 .../src/typechecker/infer/assign_expr.rs | 0 .../src/typechecker/infer/assignable.rs | 0 .../src/typechecker/infer/best_common_type.rs | 0 .../src/typechecker/infer/binding_analysis.rs | 0 .../src/typechecker/infer/classes.rs | 0 .../src/typechecker/infer/closure_arity.rs | 0 .../src/typechecker/infer/comparable.rs | 0 .../src/typechecker/infer/comparison_operand.rs | 0 .../src/typechecker/infer/diagnostics.rs | 0 .../src/typechecker/infer/enums.rs | 0 .../src/typechecker/infer/exports.rs | 0 .../src/typechecker/infer/expr.rs | 0 .../src/typechecker/infer/format_definition.rs | 0 .../src/typechecker/infer/format_signature.rs | 0 .../src/typechecker/infer/forward_globals.rs | 0 .../src/typechecker/infer/generic.rs | 0 .../src/typechecker/infer/generic_scopes.rs | 0 .../src/typechecker/infer/globals.rs | 0 .../src/typechecker/infer/iife.rs | 0 .../src/typechecker/infer/import_graph.rs | 0 .../src/typechecker/infer/imports.rs | 0 .../src/typechecker/infer/inference_sources.rs | 0 .../src/typechecker/infer/literal_freshness.rs | 0 .../src/typechecker/infer/lookup.rs | 0 .../src/typechecker/infer/mod.rs | 0 .../src/typechecker/infer/module_symbols.rs | 0 .../src/typechecker/infer/namespace_symbol.rs | 0 .../src/typechecker/infer/narrow_scopes.rs | 0 .../src/typechecker/infer/narrowing.rs | 0 .../src/typechecker/infer/nested_functions.rs | 0 .../src/typechecker/infer/object_normalization.rs | 0 .../src/typechecker/infer/param_defaults.rs | 0 .../src/typechecker/infer/predicate_envs.rs | 0 .../src/typechecker/infer/records.rs | 0 .../src/typechecker/infer/reserved.rs | 0 .../src/typechecker/infer/resolve_type.rs | 0 .../src/typechecker/infer/scopes.rs | 0 .../src/typechecker/infer/shapes.rs | 0 .../src/typechecker/infer/signatures.rs | 0 ...ecker__infer__expr__tests__snapshot_mixed_program.snap | 2 +- ...ition__tests__array_substitutes_interface_generic.snap | 2 +- ...at_definition__tests__function_renders_arrow_form.snap | 5 +++++ ...n__tests__interface_ref_substitutes_multiple_args.snap | 2 +- ...ition__tests__interface_renders_optional_property.snap | 7 +++++++ ...t_definition__tests__interface_renders_properties.snap | 8 ++++++++ ...on__tests__interface_substitutes_property_generic.snap | 7 +++++++ ...efinition__tests__object_renders_structural_shape.snap | 8 ++++++++ ...efinition__tests__primitive_with_declared_methods.snap | 7 +++++++ ...ker__infer__type_diff__tests__function_arity_diff.snap | 2 +- ...diff__tests__function_combined_arity_param_return.snap | 2 +- ...infer__type_diff__tests__function_param_type_diff.snap | 2 +- ...nfer__type_diff__tests__function_return_type_diff.snap | 2 +- ...er__type_diff__tests__object_all_three_dimensions.snap | 2 +- ...cker__infer__type_diff__tests__object_extra_field.snap | 5 +++++ ...fer__type_diff__tests__object_field_type_mismatch.snap | 2 +- ...er__infer__type_diff__tests__object_missing_field.snap | 5 +++++ .../src/typechecker/infer/stmt.rs | 0 .../src/typechecker/infer/switch_stmt.rs | 0 .../src/typechecker/infer/test_support.rs | 0 .../src/typechecker/infer/type_aliases.rs | 0 .../src/typechecker/infer/type_diff.rs | 0 .../src/typechecker/infer/type_namespace.rs | 0 .../src/typechecker/infer/type_predicate.rs | 0 .../src/typechecker/infer/type_registry.rs | 0 .../src/typechecker/infer/value_operand.rs | 0 .../src/typechecker/infer/variance.rs | 0 .../src/typechecker/json_schema.rs | 0 .../src/typechecker/json_strategy.rs | 0 .../src/typechecker/mod.rs | 0 .../src/typechecker/rules/body_walk.rs | 0 .../src/typechecker/rules/capability_consistency.rs | 0 .../src/typechecker/rules/check_calls.rs | 0 .../src/typechecker/rules/check_discipline/bodies.rs | 0 .../src/typechecker/rules/check_discipline/checked.rs | 0 .../src/typechecker/rules/check_discipline/findings.rs | 0 .../src/typechecker/rules/check_discipline/flow.rs | 0 .../src/typechecker/rules/check_discipline/mod.rs | 0 .../src/typechecker/rules/check_discipline/origin.rs | 0 .../src/typechecker/rules/check_discipline/package.rs | 0 .../src/typechecker/rules/check_discipline/scope.rs | 0 .../src/typechecker/rules/check_discipline/stability.rs | 0 .../src/typechecker/rules/check_discipline/tests.rs | 0 .../src/typechecker/rules/control_flow.rs | 0 .../src/typechecker/rules/declarations.rs | 0 .../src/typechecker/rules/definite_assignment.rs | 0 .../src/typechecker/rules/doc_consistency.rs | 0 .../src/typechecker/rules/exported_docs.rs | 0 .../src/typechecker/rules/exported_signature_types.rs | 0 .../src/typechecker/rules/fallthrough.rs | 0 .../src/typechecker/rules/main_required.rs | 0 .../src/typechecker/rules/missing_return.rs | 0 .../src/typechecker/rules/mod.rs | 0 .../src/typechecker/rules/return_outside_function.rs | 0 .../src/typechecker/rules/super_call.rs | 0 .../src/typechecker/rules/unreachable.rs | 0 .../src/typechecker/type_param_substitution.rs | 0 crates/{submilli-engine => interpreter}/src/typed_ast.rs | 0 crates/{submilli-engine => interpreter}/src/types.rs | 0 .../tests/checked_arena.rs | 0 .../tests/checked_rendering.rs | 0 .../tests/checked_source.rs | 0 .../tests/checked_typed_phases.rs | 0 .../tests/checked_untyped_phases.rs | 0 .../tests/class_rec_group.rs | 0 .../tests/closure_arity.rs | 0 .../tests/closure_arity_diagnostics.rs | 0 .../tests/closure_lowering_errors.rs | 0 .../tests/compiler_structure_limits.rs | 0 .../tests/console_failure.rs | 0 .../tests/cross_module_gc_types.rs | 0 .../tests/decision_records.rs | 0 .../{submilli-engine => interpreter}/tests/determinism.rs | 0 .../tests/diagnostic_snapshots.rs | 0 .../tests/field_lookup_size.rs | 0 crates/{submilli-engine => interpreter}/tests/fixtures.rs | 0 .../tests/fixtures/alias_index_read_write.ts | 0 .../tests/fixtures/alias_peel_dispatch.ts | 0 .../tests/fixtures/angle_bracket_cast.ts | 0 .../tests/fixtures/array_at.subm | 0 .../tests/fixtures/array_callback_truthiness.ts | 0 .../tests/fixtures/array_concat.subm | 0 .../tests/fixtures/array_copy_within.subm | 0 .../tests/fixtures/array_every.subm | 0 .../tests/fixtures/array_fill.subm | 0 .../tests/fixtures/array_filter.subm | 0 .../tests/fixtures/array_filter_guard_narrows_to_class.ts | 0 .../tests/fixtures/array_filter_type_guard_narrows.ts | 0 .../tests/fixtures/array_find.subm | 0 .../tests/fixtures/array_findindex.subm | 0 .../tests/fixtures/array_flat.subm | 0 .../tests/fixtures/array_flat_depth_budget.ts | 0 .../tests/fixtures/array_flat_depth_error.subm | 0 .../tests/fixtures/array_flatmap.subm | 0 .../tests/fixtures/array_for_each.subm | 0 .../tests/fixtures/array_from.subm | 0 .../tests/fixtures/array_from_array_like_length.ts | 0 .../tests/fixtures/array_from_array_like_wider_source.ts | 0 .../tests/fixtures/array_from_collections.ts | 0 .../tests/fixtures/array_generic_spelling.subm | 0 .../tests/fixtures/array_host_port_edges.ts | 0 .../tests/fixtures/array_includes.subm | 0 .../tests/fixtures/array_index_domain.ts | 0 .../tests/fixtures/array_index_of.subm | 0 .../tests/fixtures/array_index_oob_throws.subm | 0 .../tests/fixtures/array_indexed_write_rhs_grows.ts | 0 .../tests/fixtures/array_iter_next_result.ts | 0 .../tests/fixtures/array_join.subm | 0 .../tests/fixtures/array_join_null.ts | 0 .../tests/fixtures/array_keeps_regular_literal_types.ts | 0 .../tests/fixtures/array_keys_values_entries.subm | 0 .../tests/fixtures/array_last_index_of.subm | 0 .../tests/fixtures/array_length.subm | 0 .../tests/fixtures/array_like_union_reads.ts | 0 .../tests/fixtures/array_like_union_writes.ts | 0 .../tests/fixtures/array_literal_best_common_type.ts | 0 .../tests/fixtures/array_literal_element_order.ts | 0 .../fixtures/array_literal_normalized_to_optional.ts | 0 .../tests/fixtures/array_literal_object_normalization.ts | 0 .../array_literal_object_normalization_fresh_only.ts | 0 .../tests/fixtures/array_literal_union_of_arrays.ts | 0 .../fixtures/array_literal_union_of_arrays_mismatch.ts | 0 .../tests/fixtures/array_literal_wider_element.ts | 0 .../fixtures/array_literal_wider_element_mismatch.ts | 0 .../tests/fixtures/array_map.subm | 0 .../tests/fixtures/array_of.subm | 0 .../fixtures/array_of_object_literal_arrays_union.ts | 0 .../tests/fixtures/array_pop.subm | 0 .../tests/fixtures/array_push.subm | 0 .../tests/fixtures/array_reduce.subm | 0 .../tests/fixtures/array_reduce_right.subm | 0 .../tests/fixtures/array_reverse.subm | 0 .../tests/fixtures/array_shift_unshift.subm | 0 .../tests/fixtures/array_slice.subm | 0 .../tests/fixtures/array_some.subm | 0 .../tests/fixtures/array_sort.subm | 0 .../tests/fixtures/array_sort_cached_units.ts | 0 .../tests/fixtures/array_sort_keeps_comparator_pushes.ts | 0 .../tests/fixtures/array_sort_stable_merge.ts | 0 .../tests/fixtures/array_splice.subm | 0 .../tests/fixtures/array_spread_parameter.ts | 0 .../tests/fixtures/array_to_reversed.subm | 0 .../tests/fixtures/array_to_sorted.subm | 0 .../tests/fixtures/array_to_spliced.subm | 0 .../tests/fixtures/array_values_host_iter.ts | 0 .../tests/fixtures/array_with.subm | 0 .../tests/fixtures/arrow_return_type_forms.ts | 0 .../tests/fixtures/asi_allman_braces.ts | 0 .../tests/fixtures/asi_clause_and_arrow_wraps.ts | 0 .../tests/fixtures/asi_keyword_members.ts | 0 .../tests/fixtures/asi_line_break_after_as_type.ts | 0 .../tests/fixtures/asi_line_wrapped_operators.subm | 0 .../tests/fixtures/asi_statement_ends_at_closing_brace.ts | 0 .../tests/fixtures/asi_template_substitution_wraps.ts | 0 .../tests/fixtures/asi_type_members_in_brackets.ts | 0 .../tests/fixtures/assert_pass.subm | 0 .../tests/fixtures/assert_throws_catchable.subm | 0 .../tests/fixtures/assignment_expression.ts | 0 .../tests/fixtures/assignment_keeps_literal_types.ts | 0 .../fixtures/assignment_narrows_to_declared_member.ts | 0 .../tests/fixtures/bare_return_in_inferred_closure.ts | 0 .../tests/fixtures/bigint_arithmetic.subm | 0 .../tests/fixtures/bigint_compare.subm | 0 .../tests/fixtures/bigint_container_equality.subm | 0 .../tests/fixtures/bigint_conversions.subm | 0 .../tests/fixtures/bigint_decimal_budget.ts | 0 .../tests/fixtures/bigint_float_literal.subm | 0 .../tests/fixtures/bigint_join.subm | 0 .../tests/fixtures/bigint_large_literal.subm | 0 .../tests/fixtures/bigint_literal_basic.subm | 0 .../tests/fixtures/bigint_literal_narrowing.ts | 0 .../tests/fixtures/bigint_literal_types.ts | 0 .../tests/fixtures/bigint_namespace_typo.subm | 0 .../tests/fixtures/bigint_number_exact.ts | 0 .../tests/fixtures/bigint_plus_number.subm | 0 .../tests/fixtures/bigint_to_json.ts | 0 .../tests/fixtures/bigint_to_string_radix.subm | 0 .../tests/fixtures/bind_void_call_value.ts | 0 .../tests/fixtures/binding_scope/calls.ts | 0 .../tests/fixtures/binding_scope/capture_block_shadow.ts | 0 .../tests/fixtures/binding_scope/captured_write.ts | 0 .../tests/fixtures/binding_scope/early_assignment.ts | 0 .../tests/fixtures/binding_scope/early_namespace.ts | 0 .../tests/fixtures/binding_scope/for_of_pattern_shadow.ts | 0 .../tests/fixtures/binding_scope/for_of_pattern_tdz.ts | 0 .../tests/fixtures/binding_scope/for_of_tdz.ts | 0 .../tests/fixtures/binding_scope/hygiene.ts | 0 .../tests/fixtures/binding_scope/hygiene_array.ts | 0 .../tests/fixtures/binding_scope/hygiene_iterator.ts | 0 .../tests/fixtures/binding_scope/intrinsic.ts | 0 .../tests/fixtures/binding_scope/mutators.ts | 0 .../tests/fixtures/binding_scope/namespace.ts | 0 .../tests/fixtures/binding_scope/parseint_required_arg.ts | 0 .../tests/fixtures/binding_scope/pattern_hygiene.ts | 0 .../tests/fixtures/binding_scope/redeclare.ts | 0 .../tests/fixtures/binding_scope/redeclare_catch.ts | 0 .../tests/fixtures/binding_scope/redeclare_let.ts | 0 .../tests/fixtures/binding_scope/redeclare_param.ts | 0 .../tests/fixtures/binding_scope/redeclare_pattern.ts | 0 .../tests/fixtures/binding_scope/redeclare_rest.ts | 0 .../tests/fixtures/binding_scope/self_initialization.ts | 0 .../tests/fixtures/binding_scope/shadowing.ts | 0 .../tests/fixtures/binding_scope/tdz.ts | 0 .../tests/fixtures/bitwise/asi.ts | 0 .../tests/fixtures/bitwise/assignments.ts | 0 .../tests/fixtures/bitwise/bigints.ts | 0 .../tests/fixtures/bitwise/coercion.ts | 0 .../tests/fixtures/bitwise/evaluation.ts | 0 .../tests/fixtures/bitwise/generics.ts | 0 .../tests/fixtures/bitwise/invalid.ts | 0 .../tests/fixtures/bitwise/invalid_unary.ts | 0 .../tests/fixtures/bitwise/live_values.ts | 0 .../tests/fixtures/bitwise/numbers.ts | 0 .../tests/fixtures/boolean_literal_types.ts | 0 .../tests/fixtures/boxed_primitive_vtables.ts | 0 .../tests/fixtures/braceless_bodies_accepted.ts | 0 .../tests/fixtures/braceless_control_bodies.subm | 0 .../tests/fixtures/builtin_error.subm | 0 .../tests/fixtures/bulk_string_and_byte_copies.ts | 0 .../tests/fixtures/call_sig_number_from_string.subm | 0 .../tests/fixtures/call_sig_string_coercion.subm | 0 .../tests/fixtures/call_sig_user_interface.subm | 0 .../tests/fixtures/captured_let_same_frame_reassign.subm | 0 .../tests/fixtures/cast_and_spread_object_literals.ts | 0 .../tests/fixtures/cast_rest_function_to_fixed_arity.ts | 0 .../tests/fixtures/cast_self_nominal_interface.ts | 0 .../tests/fixtures/cast_to_union_member_overlap.ts | 0 .../tests/fixtures/cast_void_adapter_to_value_function.ts | 0 .../tests/fixtures/casts/as_array_element_check.subm | 0 .../tests/fixtures/casts/as_chain_round_trip.subm | 0 .../tests/fixtures/casts/as_enum_target.ts | 0 .../fixtures/casts/as_interface_non_object_throws.subm | 0 .../tests/fixtures/casts/as_nested_and_optional.subm | 0 .../tests/fixtures/casts/as_number_passthrough.subm | 0 .../tests/fixtures/casts/as_object_literal_field.subm | 0 .../tests/fixtures/casts/as_proven_upcast_no_check.subm | 0 .../tests/fixtures/casts/as_recursive_object.subm | 0 .../tests/fixtures/casts/as_recursive_union.subm | 0 .../tests/fixtures/casts/as_string_passthrough.subm | 0 .../tests/fixtures/casts/as_union_to_member.subm | 0 .../tests/fixtures/casts/as_unknown_to_interface.subm | 0 .../tests/fixtures/casts/as_unknown_to_object_shape.subm | 0 .../casts/expect_error_incompatible_static_cast.subm | 0 .../casts/expect_error_object_to_unrelated_interface.subm | 0 .../tests/fixtures/casts/issue_905_paths.ts | 0 .../tests/fixtures/casts/issue_982_disjoint.ts | 0 .../tests/fixtures/casts/issue_982_literal_overlap.ts | 0 .../tests/fixtures/casts/uint8array_is_as.ts | 0 .../casts/unknown_to_number_throws_and_catches.subm | 0 .../tests/fixtures/chain_generic_method_reference.ts | 0 .../tests/fixtures/chain_non_generic_optional_calls.ts | 0 .../fixtures/check_discipline/clean_destructure/lib.ts | 0 .../check_discipline/clean_destructured_param/lib.ts | 0 .../fixtures/check_discipline/clean_exported_arrow/lib.ts | 0 .../tests/fixtures/check_discipline/clean_for_of/lib.ts | 0 .../fixtures/check_discipline/clean_narrowed_root/lib.ts | 0 .../fixtures/check_discipline/clean_package_value/lib.ts | 0 .../fixtures/check_discipline/clean_primitives/lib.ts | 0 .../check_discipline/clean_response_mapping/lib.ts | 0 .../check_discipline/clean_sibling_of_checked/lib.ts | 0 .../check_discipline/clean_unchecked_payload/lib.ts | 0 .../fixtures/check_discipline/clean_unguarded/lib.ts | 0 .../fixtures/check_discipline/escape_argument/lib.ts | 0 .../fixtures/check_discipline/escape_array_literal/lib.ts | 0 .../fixtures/check_discipline/escape_callback/lib.ts | 0 .../fixtures/check_discipline/escape_captured/lib.ts | 0 .../check_discipline/escape_checked_ancestor/lib.ts | 0 .../tests/fixtures/check_discipline/escape_context/lib.ts | 0 .../tests/fixtures/check_discipline/escape_merged/lib.ts | 0 .../fixtures/check_discipline/escape_method_call/lib.ts | 0 .../fixtures/check_discipline/escape_mutation/lib.ts | 0 .../tests/fixtures/check_discipline/escape_operand/lib.ts | 0 .../fixtures/check_discipline/escape_returned/lib.ts | 0 .../tests/fixtures/check_discipline/escape_spread/lib.ts | 0 .../tests/fixtures/check_discipline/escape_stored/lib.ts | 0 .../tests/fixtures/check_discipline/escape_thrown/lib.ts | 0 .../fixtures/check_discipline/placement_closure/lib.ts | 0 .../check_discipline/placement_conditional_arrows/lib.ts | 0 .../placement_internal_module/internal.ts | 0 .../check_discipline/placement_internal_module/lib.ts | 0 .../fixtures/check_discipline/placement_members/lib.ts | 0 .../check_discipline/placement_module_level/lib.ts | 0 .../check_discipline/placement_private_helper/lib.ts | 0 .../check_discipline/placement_reexport/internal.ts | 0 .../fixtures/check_discipline/placement_reexport/lib.ts | 0 .../check_discipline/placement_unexported_arrow/lib.ts | 0 .../fixtures/check_discipline/repeated_iteration/lib.ts | 0 .../tests/fixtures/check_discipline/repeated_read/lib.ts | 0 .../fixtures/check_discipline/repeated_read_alias/lib.ts | 0 .../check_discipline/repeated_read_cast_arrow/lib.ts | 0 .../check_discipline/repeated_read_control/lib.ts | 0 .../check_discipline/repeated_read_early_exit/lib.ts | 0 .../check_discipline/repeated_read_exported_arrow/lib.ts | 0 .../fixtures/check_discipline/repeated_read_loop/lib.ts | 0 .../check_discipline/repeated_read_module_variable/lib.ts | 0 .../check_discipline/repeated_read_narrowed/lib.ts | 0 .../check_discipline/repeated_read_through_helper/lib.ts | 0 .../tests/fixtures/class_chain_at_limit.ts | 0 .../tests/fixtures/class_never_field_collection_key.ts | 0 .../tests/fixtures/class_to_string_field.ts | 0 .../fixtures/class_used_before_declaration_throws.ts | 0 .../tests/fixtures/classes/abstract_member.ts | 0 .../classes/accessor_across_package_boundary/app/main.ts | 0 .../classes/accessor_across_package_boundary/lib/lib.ts | 0 .../accessor_across_package_boundary/packages.manifest | 0 .../tests/fixtures/classes/accessor_basic.ts | 0 .../fixtures/classes/accessor_cross_package/app/main.ts | 0 .../fixtures/classes/accessor_cross_package/geo/lib.ts | 0 .../classes/accessor_cross_package/packages.manifest | 0 .../tests/fixtures/classes/accessor_different_types.ts | 0 .../tests/fixtures/classes/accessor_half_inherited.ts | 0 .../fixtures/classes/accessor_implements_readonly.ts | 0 .../classes/accessor_name_is_not_proof_of_an_accessor.ts | 0 .../tests/fixtures/classes/accessor_override.ts | 0 .../tests/fixtures/classes/accessor_readonly.ts | 0 .../fixtures/classes/accessor_redeclared_compatibly.ts | 0 .../tests/fixtures/classes/accessor_via_interface.ts | 0 .../tests/fixtures/classes/accessor_write_only.ts | 0 .../tests/fixtures/classes/bad_override.ts | 0 .../fixtures/classes/captured_class_binding_boxed.ts | 0 .../tests/fixtures/classes/cast_accessor_conformance.ts | 0 .../classes/cast_accessor_cross_package/app/main.ts | 0 .../classes/cast_accessor_cross_package/geo/lib.ts | 0 .../classes/cast_accessor_cross_package/packages.manifest | 0 .../tests/fixtures/classes/catch_generic_error_bare.ts | 0 .../tests/fixtures/classes/closure_captures_this.ts | 0 .../tests/fixtures/classes/closure_in_member_bodies.ts | 0 .../classes/compound_assign_cross_package/app/main.ts | 0 .../classes/compound_assign_cross_package/counters/lib.ts | 0 .../compound_assign_cross_package/packages.manifest | 0 .../classes/compound_assign_cross_package/tickers/lib.ts | 0 .../tests/fixtures/classes/compound_assign_field.ts | 0 .../fixtures/classes/compound_assign_generic_field.ts | 0 .../tests/fixtures/classes/construct_and_read_fields.ts | 0 .../classes/ctor_class_param_cross_package/app/main.ts | 0 .../classes/ctor_class_param_cross_package/lib/lib.ts | 0 .../ctor_class_param_cross_package/packages.manifest | 0 .../tests/fixtures/classes/ctor_default_and_rest.ts | 0 .../classes/ctor_default_rest_cross_package/app/main.ts | 0 .../classes/ctor_default_rest_cross_package/lib/lib.ts | 0 .../ctor_default_rest_cross_package/packages.manifest | 0 .../classes/dispatched_defaults_packages/app/main.ts | 0 .../classes/dispatched_defaults_packages/lib/lib.ts | 0 .../dispatched_defaults_packages/packages.manifest | 0 .../tests/fixtures/classes/dynamic_dispatch.ts | 0 .../fixtures/classes/equals_cross_package/app/main.ts | 0 .../fixtures/classes/equals_cross_package/labeled/lib.ts | 0 .../classes/equals_cross_package/packages.manifest | 0 .../fixtures/classes/equals_cross_package/points/lib.ts | 0 .../tests/fixtures/classes/equals_error.ts | 0 .../tests/fixtures/classes/equals_nullable_field.ts | 0 .../tests/fixtures/classes/equals_sibling_same_shape.ts | 0 .../tests/fixtures/classes/equals_structural_fields.ts | 0 .../tests/fixtures/classes/equals_subclass_vs_base.ts | 0 .../fixtures/classes/equals_vs_other_runtime_types.ts | 0 .../tests/fixtures/classes/error_catch_closure_capture.ts | 0 .../tests/fixtures/classes/error_field_mutation.ts | 0 .../tests/fixtures/classes/error_subclass_basic.ts | 0 .../classes/error_subclass_cross_package/app/main.ts | 0 .../classes/error_subclass_cross_package/errs/lib.ts | 0 .../error_subclass_cross_package/packages.manifest | 0 .../tests/fixtures/classes/error_subclass_throw_catch.ts | 0 .../tests/fixtures/classes/error_subclass_typed_catch.ts | 0 .../classes/error_subclass_typed_catch_finally.ts | 0 .../tests/fixtures/classes/error_union_null.ts | 0 .../fixtures/classes/expect_error_accessor_half_guards.ts | 0 .../expect_error_accessor_redeclared_incompatibly.ts | 0 .../classes/expect_error_accessor_type_mismatch.ts | 0 .../classes/expect_error_assign_missing_static.ts | 0 .../app/main.ts | 0 .../counters/lib.ts | 0 .../packages.manifest | 0 .../expect_error_assign_private_static/app/main.ts | 0 .../expect_error_assign_private_static/counters/lib.ts | 0 .../expect_error_assign_private_static/packages.manifest | 0 .../app/main.ts | 0 .../counters/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_assign_static_method.ts | 0 .../classes/expect_error_assign_static_readonly.ts | 0 .../classes/expect_error_assign_static_wrong_type.ts | 0 .../fixtures/classes/expect_error_assign_to_method.ts | 0 .../fixtures/classes/expect_error_bare_class_value.ts | 0 .../fixtures/classes/expect_error_catch_generic_args.ts | 0 .../fixtures/classes/expect_error_catch_non_error.ts | 0 .../classes/expect_error_catch_unrelated_class.ts | 0 .../classes/expect_error_compound_assign_readonly.ts | 0 .../classes/expect_error_ctor_arity_default_rest.ts | 0 .../classes/expect_error_deep_chain_shape_dump.ts | 0 .../classes/expect_error_field_redeclared_visibility.ts | 0 .../classes/expect_error_field_redeclared_wider.ts | 0 .../expect_error_field_used_before_initialization.ts | 0 .../classes/expect_error_generic_chain_shape_dump.ts | 0 .../classes/expect_error_getter_only_vs_settable.ts | 0 .../classes/expect_error_implements_aliased_interface.ts | 0 .../expect_error_implements_aliased_non_interface.ts | 0 .../classes/expect_error_implements_missing_member.ts | 0 .../classes/expect_error_implements_wrong_arity.ts | 0 .../classes/expect_error_implements_wrong_signature.ts | 0 .../fixtures/classes/expect_error_instance_on_class.ts | 0 .../fixtures/classes/expect_error_instanceof_interface.ts | 0 .../expect_error_instanceof_uint8array_unrelated.ts | 0 .../fixtures/classes/expect_error_instanceof_unrelated.ts | 0 .../classes/expect_error_member_closures_and_switches.ts | 0 .../classes/expect_error_member_missing_return.ts | 0 .../classes/expect_error_member_unreachable_code.ts | 0 .../classes/expect_error_method_switch_fallthrough.ts | 0 .../classes/expect_error_optional_vs_required_member.ts | 0 .../classes/expect_error_override_fewer_params.ts | 0 .../classes/expect_error_param_prop_outside_ctor.ts | 0 .../classes/expect_error_postfix_static_readonly.ts | 0 .../classes/expect_error_postfix_static_string.ts | 0 .../grand.ts | 0 .../expect_error_private_constructor_cross_module/lib.ts | 0 .../point.ts | 0 .../app/main.ts | 0 .../packages.manifest | 0 .../shapes/lib.ts | 0 .../fixtures/classes/expect_error_read_write_only.ts | 0 .../classes/expect_error_readonly_field_vs_settable.ts | 0 .../expect_error_redeclared_at_a_different_kind.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_static_accessor.ts | 0 .../fixtures/classes/expect_error_static_class_generic.ts | 0 .../fixtures/classes/expect_error_static_constructor.ts | 0 .../fixtures/classes/expect_error_static_field_no_init.ts | 0 .../expect_error_static_instance_name_collision.ts | 0 .../fixtures/classes/expect_error_static_on_instance.ts | 0 .../classes/expect_error_static_on_instance_help.ts | 0 .../classes/expect_error_static_optional_field.ts | 0 .../tests/fixtures/classes/expect_error_static_this.ts | 0 .../expect_error_static_via_namespace_import/app/main.ts | 0 .../expect_error_static_via_namespace_import/mathx/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/expect_error_subclass_shape_dump.ts | 0 .../fixtures/classes/expect_error_to_string_signature.ts | 0 .../classes/expect_error_type_beats_mutability.ts | 0 .../fixtures/classes/expect_error_uninitialized_field.ts | 0 .../classes/expect_error_uninitialized_one_branch.ts | 0 .../tests/fixtures/classes/expect_error_unknown_static.ts | 0 .../fixtures/classes/extends_cross_module/app/main.ts | 0 .../classes/extends_cross_module/packages.manifest | 0 .../fixtures/classes/extends_cross_module/zoo/animal.ts | 0 .../fixtures/classes/extends_cross_module/zoo/lib.ts | 0 .../fixtures/classes/extends_cross_package/animals/lib.ts | 0 .../fixtures/classes/extends_cross_package/app/main.ts | 0 .../fixtures/classes/extends_cross_package/dogs/lib.ts | 0 .../classes/extends_cross_package/packages.manifest | 0 .../classes/extends_cross_package_private/animals/lib.ts | 0 .../classes/extends_cross_package_private/app/main.ts | 0 .../extends_cross_package_private/packages.manifest | 0 .../tests/fixtures/classes/extends_cycle.ts | 0 .../tests/fixtures/classes/extends_non_class.ts | 0 .../tests/fixtures/classes/field_init_inherited.ts | 0 .../tests/fixtures/classes/field_initializers.ts | 0 .../fixtures/classes/field_narrowing_guard_all_reads.ts | 0 .../classes/field_narrowing_guard_ancestor_view.ts | 0 .../classes/field_narrowing_guard_cast_interface.ts | 0 .../fixtures/classes/field_narrowing_guard_constructor.ts | 0 .../field_narrowing_guard_cross_package/app/main.ts | 0 .../field_narrowing_guard_cross_package/lib/lib.ts | 0 .../field_narrowing_guard_cross_package/packages.manifest | 0 .../tests/fixtures/classes/field_narrowing_guard_enums.ts | 0 .../classes/field_narrowing_guard_erased_method.ts | 0 .../classes/field_narrowing_guard_factory_constructor.ts | 0 .../fixtures/classes/field_narrowing_guard_generic_box.ts | 0 .../classes/field_narrowing_guard_generic_context.ts | 0 .../classes/field_narrowing_guard_generic_factory.ts | 0 .../classes/field_narrowing_guard_generic_payload.ts | 0 .../field_narrowing_guard_hidden_package/app/main.ts | 0 .../field_narrowing_guard_hidden_package/lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/field_narrowing_guard_host_info.ts | 0 .../classes/field_narrowing_guard_nullable_factory.ts | 0 .../classes/field_narrowing_guard_nullable_interface.ts | 0 .../classes/field_narrowing_guard_union_interface.ts | 0 .../classes/field_redeclared_cross_package/app/main.ts | 0 .../classes/field_redeclared_cross_package/lib/lib.ts | 0 .../field_redeclared_cross_package/packages.manifest | 0 .../fixtures/classes/field_redeclared_in_subclass.ts | 0 .../classes/field_redeclared_narrowing_write_throws.ts | 0 .../field_redeclared_private_cross_package/app/main.ts | 0 .../field_redeclared_private_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../classes/field_redeclared_without_initializer.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../fixtures/classes/implements_aliased_interface.ts | 0 .../fixtures/classes/implements_inherited_accessor.ts | 0 .../implements_inherited_cross_package/app/main.ts | 0 .../implements_inherited_cross_package/base/lib.ts | 0 .../implements_inherited_cross_package/packages.manifest | 0 .../classes/implements_inherited_empty_subclass.ts | 0 .../fixtures/classes/implements_inherited_generic_base.ts | 0 .../classes/implements_inherited_partial_override.ts | 0 .../classes/implements_inherited_subclass_extra_member.ts | 0 .../tests/fixtures/classes/implements_interface.ts | 0 .../classes/implements_via_later_declared_parent.ts | 0 .../tests/fixtures/classes/implicit_ctor.ts | 0 .../fixtures/classes/instanceof_cross_module/animals.ts | 0 .../tests/fixtures/classes/instanceof_cross_module/lib.ts | 0 .../fixtures/classes/instanceof_cross_package/app/main.ts | 0 .../classes/instanceof_cross_package/packages.manifest | 0 .../classes/instanceof_cross_package/rects/lib.ts | 0 .../classes/instanceof_cross_package/shapes/lib.ts | 0 .../tests/fixtures/classes/instanceof_error_chain.ts | 0 .../tests/fixtures/classes/instanceof_narrow.ts | 0 .../tests/fixtures/classes/instanceof_negative.ts | 0 .../fixtures/classes/instanceof_sibling_same_shape.ts | 0 .../tests/fixtures/classes/instanceof_uint8array.ts | 0 .../instanceof_uint8array_cross_package/app/main.ts | 0 .../instanceof_uint8array_cross_package/bytes/lib.ts | 0 .../instanceof_uint8array_cross_package/packages.manifest | 0 .../fixtures/classes/instanceof_uint8array_generic.ts | 0 .../fixtures/classes/instanceof_uint8array_host_built.ts | 0 .../fixtures/classes/instanceof_uint8array_narrow.ts | 0 .../tests/fixtures/classes/instanceof_unknown_lhs.ts | 0 .../tests/fixtures/classes/issue_927.ts | 0 .../tests/fixtures/classes/issue_927_argument_order.ts | 0 .../tests/fixtures/classes/issue_927_cycle.ts | 0 .../tests/fixtures/classes/issue_927_fixed_cycle.ts | 0 .../tests/fixtures/classes/issue_927_interface.ts | 0 .../tests/fixtures/classes/issue_927_union_cycle.ts | 0 .../fixtures/classes/issue_967_checked_return_abi.ts | 0 .../tests/fixtures/classes/issue_967_default_interface.ts | 0 .../tests/fixtures/classes/issue_967_required.ts | 0 .../fixtures/classes/issue_967_structural_defaults.ts | 0 .../tests/fixtures/classes/issue_967_wrong_parameter.ts | 0 .../fixtures/classes/issue_973_shorthand_boundary.ts | 0 .../tests/fixtures/classes/issue_987_inline_object.ts | 0 .../tests/fixtures/classes/issue_987_private.ts | 0 .../tests/fixtures/classes/issue_987_setter_only.ts | 0 .../tests/fixtures/classes/issue_987_weak_target.ts | 0 .../fixtures/classes/json_inherited_private/app/main.ts | 0 .../fixtures/classes/json_inherited_private/lib/lib.ts | 0 .../classes/json_inherited_private/packages.manifest | 0 .../tests/fixtures/classes/json_public_properties.ts | 0 .../tests/fixtures/classes/map_set_class_keys.ts | 0 .../tests/fixtures/classes/method_dispatch.ts | 0 .../classes/method_rewritten_cross_package/app/main.ts | 0 .../classes/method_rewritten_cross_package/lib/lib.ts | 0 .../method_rewritten_cross_package/packages.manifest | 0 .../fixtures/classes/method_rewritten_through_alias.ts | 0 .../classes/multi_catch_cross_package/app/main.ts | 0 .../classes/multi_catch_cross_package/errs/lib.ts | 0 .../classes/multi_catch_cross_package/packages.manifest | 0 .../classes/mutable_conversion_cross_package/app/main.ts | 0 .../classes/mutable_conversion_cross_package/base/lib.ts | 0 .../mutable_conversion_cross_package/packages.manifest | 0 .../fixtures/classes/object_literal_in_member_bodies.ts | 0 .../tests/fixtures/classes/overridden_defaults.ts | 0 .../tests/fixtures/classes/param_properties.ts | 0 .../fixtures/classes/permission_denied_error_builtin.ts | 0 .../tests/fixtures/classes/postfix_field_expression.ts | 0 .../classes/private_constructor_packages/app/main.ts | 0 .../private_constructor_packages/packages.manifest | 0 .../classes/private_constructor_packages/shapes/lib.ts | 0 .../tests/fixtures/classes/private_cross_module/animal.ts | 0 .../tests/fixtures/classes/private_cross_module/lib.ts | 0 .../tests/fixtures/classes/protected_member.ts | 0 .../tests/fixtures/classes/quota_exceeded_error.ts | 0 .../tests/fixtures/classes/range_error_builtin.ts | 0 .../tests/fixtures/classes/range_error_host_throws.ts | 0 .../tests/fixtures/classes/readonly_write_outside_ctor.ts | 0 .../classes/recursive_guard_same_name_packages/a/lib.ts | 0 .../recursive_guard_same_name_packages/app/main.ts | 0 .../classes/recursive_guard_same_name_packages/b/lib.ts | 0 .../recursive_guard_same_name_packages/packages.manifest | 0 .../tests/fixtures/classes/setter_assignment_as_value.ts | 0 .../fixtures/classes/static_and_instance_same_name.ts | 0 .../app/main.ts | 0 .../lib/lib.ts | 0 .../packages.manifest | 0 .../classes/static_classref_cross_package/app/main.ts | 0 .../classes/static_classref_cross_package/lib/lib.ts | 0 .../static_classref_cross_package/packages.manifest | 0 .../fixtures/classes/static_cross_package/app/main.ts | 0 .../fixtures/classes/static_cross_package/mathx/lib.ts | 0 .../classes/static_cross_package/packages.manifest | 0 .../tests/fixtures/classes/static_generic_method.ts | 0 .../tests/fixtures/classes/static_inheritance.ts | 0 .../fixtures/classes/static_instance_name_collision.ts | 0 .../fixtures/classes/static_members_do_not_redeclare.ts | 0 .../tests/fixtures/classes/static_method_as_value.ts | 0 .../tests/fixtures/classes/static_method_basic.ts | 0 .../tests/fixtures/classes/static_mutable_assign.ts | 0 .../classes/static_mutable_cross_package/app/main.ts | 0 .../classes/static_mutable_cross_package/counters/lib.ts | 0 .../static_mutable_cross_package/packages.manifest | 0 .../tests/fixtures/classes/static_mutable_field.ts | 0 .../fixtures/classes/static_mutable_inherited_write.ts | 0 .../tests/fixtures/classes/static_mutable_postfix.ts | 0 .../tests/fixtures/classes/static_mutable_private.ts | 0 .../tests/fixtures/classes/static_private.ts | 0 .../tests/fixtures/classes/static_readonly_field.ts | 0 .../classes/static_ref_types_cross_package/app/main.ts | 0 .../static_ref_types_cross_package/packages.manifest | 0 .../classes/static_ref_types_cross_package/strx/lib.ts | 0 .../tests/fixtures/classes/super_chain.ts | 0 .../tests/fixtures/classes/super_ctor_field_init.ts | 0 .../tests/fixtures/classes/super_method_override.ts | 0 .../tests/fixtures/classes/syntax_error_builtin.ts | 0 .../tests/fixtures/classes/this_in_field_initializer.ts | 0 .../tests/fixtures/classes/this_outside_method.ts | 0 .../transitive_dep_closure_cross_package/app/main.ts | 0 .../transitive_dep_closure_cross_package/lib1/lib.ts | 0 .../transitive_dep_closure_cross_package/lib2/lib.ts | 0 .../transitive_dep_closure_cross_package/mid/lib.ts | 0 .../packages.manifest | 0 .../app/main.ts | 0 .../lib1/lib.ts | 0 .../lib2/lib.ts | 0 .../mid/lib.ts | 0 .../packages.manifest | 0 .../tests/fixtures/classes/type_error_builtin.ts | 0 .../tests/fixtures/classes/type_error_host_thrown.ts | 0 .../classes/typed_catch_cross_package/app/main.ts | 0 .../classes/typed_catch_cross_package/errs/lib.ts | 0 .../classes/typed_catch_cross_package/packages.manifest | 0 .../tests/fixtures/classes/undefined_reference_error.ts | 0 .../tests/fixtures/classes/universal_to_json.ts | 0 .../tests/fixtures/classes/universal_to_string.ts | 0 .../unused_static_thirdpkg_cross_package/app/main.ts | 0 .../unused_static_thirdpkg_cross_package/base/lib.ts | 0 .../unused_static_thirdpkg_cross_package/consumer/lib.ts | 0 .../unused_static_thirdpkg_cross_package/mid/lib.ts | 0 .../packages.manifest | 0 .../unused_statics_not_imported_cross_package/app/main.ts | 0 .../unused_statics_not_imported_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../tests/fixtures/closure_captures_class_union.ts | 0 .../fixtures/closure_coercion_cross_package/app/main.ts | 0 .../fixtures/closure_coercion_cross_package/lib/lib.ts | 0 .../closure_coercion_cross_package/packages.manifest | 0 .../tests/fixtures/closure_counter.subm | 0 .../tests/fixtures/closure_nullable_return.ts | 0 .../tests/fixtures/closure_reads_later_module_variable.ts | 0 .../tests/fixtures/closure_sig_accessor_dispatch.ts | 0 .../tests/fixtures/closure_sig_after_substitution.ts | 0 .../tests/fixtures/closure_sig_from_class_members.ts | 0 .../tests/fixtures/closure_sig_from_local_slot.ts | 0 .../fixtures/closure_sig_from_uncalled_signatures.ts | 0 .../tests/fixtures/closure_sig_shape_dispatch.ts | 0 .../tests/fixtures/closure_that_only_throws_is_never.ts | 0 .../tests/fixtures/closure_variable_passed_to_hof.subm | 0 .../fixtures/closures/callbacks_declare_fewer_params.ts | 0 .../tests/fixtures/closures/function_arity_edges.ts | 0 .../tests/fixtures/closures/function_this.ts | 0 .../tests/fixtures/closures/iife.subm | 0 .../tests/fixtures/closures/named_function_expression.ts | 0 .../tests/fixtures/closures/nested_function_contexts.ts | 0 .../fixtures/closures/nested_function_declarations.ts | 0 .../tests/fixtures/code/linear_diff.ts | 0 .../tests/fixtures/code/workspace.ts | 0 .../tests/fixtures/collection_iterators_live.ts | 0 .../tests/fixtures/collection_keys_same_value_zero.ts | 0 .../fixtures/collection_regressions/array_from_mapping.ts | 0 .../collection_regressions/array_from_nullable.ts | 0 .../fixtures/collection_regressions/array_postfix_only.ts | 0 .../expect_error_optional_tuple_index.ts | 0 .../collection_regressions/expect_error_spread_arity.ts | 0 .../collection_regressions/expect_error_spread_array.ts | 0 .../collection_regressions/expect_error_spread_slot.ts | 0 .../fixtures/collection_regressions/optional_index.ts | 0 .../collection_regressions/optional_index_bounds.ts | 0 .../tests/fixtures/collection_regressions/spread_order.ts | 0 .../tests/fixtures/collection_regressions/tuple_boxing.ts | 0 .../tests/fixtures/collection_regressions/tuple_spread.ts | 0 .../fixtures/collection_regressions/uint8_postfix.ts | 0 .../fixtures/collection_regressions/uint8_postfix_only.ts | 0 .../tests/fixtures/collection_to_string_tag.ts | 0 .../fixtures/comparable_methods_and_self_references.ts | 0 .../fixtures/compound_assign/compound_basic_number.subm | 0 .../tests/fixtures/compound_assign/compound_bigint.subm | 0 .../fixtures/compound_assign/compound_const_error.subm | 0 .../tests/fixtures/compound_assign/compound_field.subm | 0 .../tests/fixtures/compound_assign/compound_for_loop.subm | 0 .../tests/fixtures/compound_assign/compound_index.subm | 0 .../fixtures/compound_assign/compound_narrowing.subm | 0 .../fixtures/compound_assign/compound_pow_precedence.subm | 0 .../tests/fixtures/compound_assign/compound_string.subm | 0 .../compound_assign/compound_type_error_mixed.subm | 0 .../compound_assign/compound_type_error_string_sub.subm | 0 .../fixtures/compound_assign/receiver_evaluated_once.ts | 0 .../fixtures/compound_assignment_through_never_getter.ts | 0 .../fixtures/compound_write_widens_literal_target.ts | 0 .../fixtures/conditional_object_literal_normalization.ts | 0 .../tests/fixtures/conformance_array.subm | 0 .../tests/fixtures/conformance_bigint.subm | 0 .../tests/fixtures/conformance_boolean.subm | 0 .../tests/fixtures/conformance_json.subm | 0 .../tests/fixtures/conformance_map_set.subm | 0 .../tests/fixtures/conformance_math.subm | 0 .../tests/fixtures/conformance_number.subm | 0 .../tests/fixtures/conformance_object.subm | 0 .../tests/fixtures/conformance_regexp.subm | 0 .../tests/fixtures/conformance_string.subm | 0 .../tests/fixtures/conformance_temporal.subm | 0 .../tests/fixtures/conformance_uint8array.subm | 0 .../tests/fixtures/console_log_null.ts | 0 .../tests/fixtures/console_log_variadic.subm | 0 .../fixtures/const_keeps_literals_through_operators.ts | 0 .../fixtures/const_literal_survives_through_ternaries.ts | 0 .../fixtures/const_literal_survives_where_immutable.ts | 0 .../tests/fixtures/const_literal_widens_where_mutable.ts | 0 .../tests/fixtures/constant_expression_literal_types.ts | 0 .../tests/fixtures/constant_key_reads_as_field.ts | 0 .../fixtures/contextual-keywords/all_five_as_names.ts | 0 .../contextual-keywords/asi_newline_before_as_splits.ts | 0 .../contextual-keywords/for_of_binding_named_of.ts | 0 .../fixtures/contextual-keywords/from_binding_template.ts | 0 .../contextual-keywords/keyword_positions_still_work.ts | 0 .../contextual-keywords/type_only_import_inline.ts | 0 .../contextual-keywords/type_only_import_statement.ts | 0 .../tests/fixtures/conversion_field_rest_and_this.ts | 0 .../tests/fixtures/crypto/hmac_sha256.subm | 0 .../tests/fixtures/crypto/random_bytes.subm | 0 .../tests/fixtures/crypto/sha256.subm | 0 .../tests/fixtures/crypto/sha512.subm | 0 .../tests/fixtures/crypto/timing_safe_equal.subm | 0 .../tests/fixtures/cyclic_graph_host_walk.ts | 0 .../tests/fixtures/date_lowercase_variable_works.subm | 0 .../tests/fixtures/decode_uri_lone_surrogates.ts | 0 .../tests/fixtures/default_param_arrow.ts | 0 .../tests/fixtures/default_param_basic.subm | 0 .../tests/fixtures/default_param_before_required.ts | 0 .../tests/fixtures/default_param_boxed_slot.ts | 0 .../tests/fixtures/default_param_enum_variant.subm | 0 .../tests/fixtures/default_param_expression.ts | 0 .../tests/fixtures/default_param_global_const.ts | 0 .../tests/fixtures/default_param_method.subm | 0 .../tests/fixtures/destructuring/array_hole.subm | 0 .../fixtures/destructuring/array_literal_as_tuple.subm | 0 .../tests/fixtures/destructuring/array_positional.subm | 0 .../tests/fixtures/destructuring/array_rest.subm | 0 .../fixtures/destructuring/arrow_param_expr_body.subm | 0 .../tests/fixtures/destructuring/class_member_params.ts | 0 .../fixtures/destructuring/defaults_pad_literal_tuple.ts | 0 .../expect_error_annotated_undefined_component_default.ts | 0 .../destructuring/expect_error_array_literal_arity.subm | 0 .../destructuring/expect_error_for_initializer_capture.ts | 0 .../destructuring/expect_error_for_initializer_parse.ts | 0 .../fixtures/destructuring/expect_error_for_of_arity.subm | 0 .../destructuring/expect_error_for_of_non_tuple.subm | 0 .../tests/fixtures/destructuring/expect_error_nested.subm | 0 .../expect_error_pattern_longer_than_literal.ts | 0 .../destructuring/expect_error_rest_not_last.subm | 0 .../tests/fixtures/destructuring/for_initializer.ts | 0 .../tests/fixtures/destructuring/for_of_map.subm | 0 .../tests/fixtures/destructuring/for_of_tuple.subm | 0 .../tests/fixtures/destructuring/function_param.subm | 0 .../fixtures/destructuring/let_pattern_mutation.subm | 0 .../tests/fixtures/destructuring/nested_in_block.subm | 0 .../tests/fixtures/destructuring/object_rename.subm | 0 .../tests/fixtures/destructuring/object_rest.subm | 0 .../tests/fixtures/destructuring/object_shorthand.subm | 0 .../tests/fixtures/destructuring/parameter_defaults.ts | 0 .../tests/fixtures/destructuring/pattern_defaults.ts | 0 .../tests/fixtures/destructuring/single_eval_rhs.subm | 0 .../tests/fixtures/destructuring_initializer_flow.ts | 0 .../tests/fixtures/diagnostic_counts/accessor.ts | 0 .../tests/fixtures/diagnostic_counts/array.ts | 0 .../tests/fixtures/diagnostic_counts/getter.ts | 0 .../tests/fixtures/diagnostic_counts/interface.ts | 0 .../diagnostic_counts/package_warnings/dep/lib.ts | 0 .../diagnostic_counts/package_warnings/packages.manifest | 0 .../diagnostic_counts/package_warnings/root/main.ts | 0 .../diagnostic_counts/package_warnings_error/dep/lib.ts | 0 .../package_warnings_error/packages.manifest | 0 .../diagnostic_counts/package_warnings_error/root/main.ts | 0 .../tests/fixtures/diagnostic_counts/spread_array.ts | 0 .../tests/fixtures/diagnostic_counts/spread_tuple.ts | 0 .../tests/fixtures/diagnostic_counts/tuple.ts | 0 .../tests/fixtures/diagnostic_counts/unhinted_array.ts | 0 .../fixtures/discriminated_union_object_literal.subm | 0 .../tests/fixtures/doc_callable_members.ts | 0 .../fixtures/doc_comments/capability_context_fields.ts | 0 ...xpect_error_payload_key_missing_from_capability_doc.ts | 0 ...t_warning_capability_binding_missing_from_payload.subm | 0 .../expect_warning_missing_capability_tag.subm | 0 .../doc_comments/expect_warning_missing_param_doc.subm | 0 .../tests/fixtures/duplicate_parameter_names.ts | 0 .../tests/fixtures/embedding_basic.ts | 0 .../tests/fixtures/embedding_bounds.ts | 0 .../tests/fixtures/embedding_budget_per_run.ts | 0 .../tests/fixtures/embedding_denied.ts | 0 .../tests/fixtures/embedding_error_taxonomy.ts | 0 .../tests/fixtures/embedding_input_too_long.ts | 0 .../tests/fixtures/embedding_models.ts | 0 .../tests/fixtures/embedding_models_filtered.ts | 0 .../tests/fixtures/embedding_no_provider.ts | 0 .../tests/fixtures/embedding_purpose_invalid.ts | 0 .../tests/fixtures/embedding_unknown_alias.ts | 0 .../tests/fixtures/emitter_fallible_healthy.ts | 0 .../tests/fixtures/emitter_state_healthy.ts | 0 .../tests/fixtures/empty_array_cast.ts | 0 .../tests/fixtures/empty_array_cast_non_array.ts | 0 .../tests/fixtures/empty_array_never.ts | 0 .../fixtures/enum_member_cases_match_their_own_enum.ts | 0 .../tests/fixtures/enum_member_comparison_narrows.ts | 0 .../tests/fixtures/enum_member_types.ts | 0 .../tests/fixtures/enum_negative_zero_initializer.ts | 0 .../fixtures/enums/enum_decl_numeric_typechecks.subm | 0 .../tests/fixtures/enums/enum_decl_string_typechecks.subm | 0 .../tests/fixtures/enums/enum_runtime_numeric.subm | 0 .../tests/fixtures/enums/enum_runtime_string.subm | 0 .../tests/fixtures/enums/expect_error_enum_as_value.subm | 0 .../fixtures/enums/expect_error_enum_mixed_kinds.subm | 0 .../enums/expect_error_enum_string_missing_value.subm | 0 .../fixtures/enums/expect_error_enum_unknown_variant.subm | 0 .../tests/fixtures/equality_comparable_operands.ts | 0 .../tests/fixtures/equality_literal_operands.ts | 0 .../tests/fixtures/error_constructor_default_message.ts | 0 .../tests/fixtures/error_is_error.subm | 0 .../tests/fixtures/error_is_error_nominal.ts | 0 .../tests/fixtures/error_subclass_object_keys.ts | 0 .../tests/fixtures/error_subclass_to_string.ts | 0 .../tests/fixtures/errors/call_sig_duplicate.subm | 0 .../tests/fixtures/errors/call_sig_not_callable.subm | 0 .../tests/fixtures/errors/default_param_in_fn_type.subm | 0 .../fixtures/errors/default_param_type_mismatch.subm | 0 .../errors/expect_error_reserved_keyword_binding.subm | 0 .../tests/fixtures/errors/issue_918_partial_catalog.ts | 0 .../tests/fixtures/errors/new_no_constructor.subm | 0 .../tests/fixtures/errors/new_no_parens.subm | 0 .../tests/fixtures/errors/postfix_inc_chain.subm | 0 .../tests/fixtures/errors/postfix_inc_const.subm | 0 .../tests/fixtures/errors/postfix_inc_non_numeric.subm | 0 .../fixtures/exceptions/break_outside_finally_scope.subm | 0 .../tests/fixtures/exceptions/catch_binding_reassign.ts | 0 .../tests/fixtures/exceptions/catch_bindingless.ts | 0 .../fixtures/exceptions/catch_runs_only_when_thrown.subm | 0 .../tests/fixtures/exceptions/catch_unknown.ts | 0 .../fixtures/exceptions/catch_untyped_binds_error.ts | 0 .../continue_in_try_finally_advances_for_loop.subm | 0 .../exceptions/continue_in_try_finally_for_of.subm | 0 .../exceptions/continue_in_try_finally_ordering.subm | 0 .../tests/fixtures/exceptions/deep_finally_transfers.ts | 0 .../tests/fixtures/exceptions/error_default_name.subm | 0 .../fixtures/exceptions/expect_error_bare_throw.subm | 0 .../tests/fixtures/exceptions/expect_error_bare_try.subm | 0 .../exceptions/expect_error_bindingless_catch_order.ts | 0 .../fixtures/exceptions/expect_error_catch_any_binding.ts | 0 .../expect_error_catch_binding_reassign_non_error.ts | 0 .../exceptions/expect_error_catch_non_error_type.subm | 0 .../exceptions/expect_error_catch_unknown_duplicate.ts | 0 .../exceptions/expect_error_catch_unknown_order.ts | 0 .../expect_error_multi_catch_after_catch_all.ts | 0 .../expect_error_multi_catch_duplicate_class.ts | 0 .../expect_error_multi_catch_general_before_specific.ts | 0 .../fixtures/exceptions/expect_error_throw_non_error.subm | 0 .../tests/fixtures/exceptions/finally_caught_path.subm | 0 .../finally_no_return_preserves_catch_rethrow.subm | 0 .../tests/fixtures/exceptions/finally_normal_path.subm | 0 .../exceptions/finally_preserves_pending_completion.ts | 0 .../finally_return_suppresses_catch_rethrow.subm | 0 .../tests/fixtures/exceptions/finally_runs_on_break.subm | 0 .../fixtures/exceptions/finally_runs_on_continue.subm | 0 .../tests/fixtures/exceptions/finally_runs_on_return.subm | 0 .../exceptions/finally_runs_on_return_in_catch.subm | 0 .../fixtures/exceptions/finally_transfer_runs_once.ts | 0 .../fixtures/exceptions/finally_with_own_return_wins.subm | 0 .../exceptions/multi_catch_conditional_narrowing.ts | 0 .../exceptions/multi_catch_fallthrough_general.ts | 0 .../fixtures/exceptions/multi_catch_finally_every_arm.ts | 0 .../tests/fixtures/exceptions/multi_catch_first_match.ts | 0 .../exceptions/multi_catch_return_in_arm_runs_finally.ts | 0 .../fixtures/exceptions/multi_catch_subclass_dispatch.ts | 0 .../exceptions/multi_catch_throw_in_arm_runs_finally.ts | 0 .../fixtures/exceptions/multi_catch_unmatched_rethrows.ts | 0 .../fixtures/exceptions/nested_finally_on_return.subm | 0 .../tests/fixtures/exceptions/nested_try.subm | 0 .../fixtures/exceptions/nested_try_finally_break.subm | 0 .../exceptions/return_in_finally_continues_outward.ts | 0 .../tests/fixtures/exceptions/throw_caught.subm | 0 .../exceptions/throw_in_function_caught_outside.subm | 0 .../expect_error_accessor_skipped_by_duplicate.ts | 0 .../fixtures/expect_error_annotated_callback_conflict.ts | 0 .../expect_error_annotated_destructuring_default.ts | 0 .../fixtures/expect_error_annotated_for_of_default.ts | 0 .../expect_error_array_from_array_like_element_type.ts | 0 ...expect_error_array_from_array_like_without_callback.ts | 0 .../expect_error_array_from_interface_array_like.ts | 0 .../expect_error_array_from_keyed_array_like.subm | 0 .../expect_error_array_keeps_regular_literal_type.ts | 0 .../fixtures/expect_error_array_type_after_line_break.ts | 0 .../fixtures/expect_error_arrow_body_and_signature.ts | 0 .../expect_error_assignment_expression_to_const.ts | 0 .../fixtures/expect_error_assignment_reported_once.ts | 0 .../fixtures/expect_error_bigint_literal_type_mismatch.ts | 0 .../expect_error_boolean_literal_type_mismatch.ts | 0 .../fixtures/expect_error_braceless_declaration_body.ts | 0 .../tests/fixtures/expect_error_braceless_declarations.ts | 0 .../fixtures/expect_error_break_in_nested_function.ts | 0 .../tests/fixtures/expect_error_callback_param_type.ts | 0 .../fixtures/expect_error_callback_return_mismatch.ts | 0 .../fixtures/expect_error_callback_too_many_params.ts | 0 .../fixtures/expect_error_callback_untyped_extra_param.ts | 0 .../expect_error_cast_union_without_member_overlap.ts | 0 .../tests/fixtures/expect_error_class_chain_limit.ts | 0 .../tests/fixtures/expect_error_class_in_function.ts | 0 .../expect_error_comparable_function_properties.ts | 0 .../tests/fixtures/expect_error_comparison_never_true.ts | 0 .../expect_error_compound_write_reads_base_type.ts | 0 .../expect_error_condition_write_after_narrowing.ts | 0 ...ct_error_conditional_assignment_keeps_declared_type.ts | 0 .../expect_error_const_literal_operators_mismatch.ts | 0 .../fixtures/expect_error_const_literal_union_mismatch.ts | 0 .../expect_error_constant_key_write_ends_field_guard.ts | 0 .../tests/fixtures/expect_error_date_constructor.subm | 0 .../tests/fixtures/expect_error_date_now.subm | 0 .../tests/fixtures/expect_error_date_type.subm | 0 ...xpect_error_default_parameter_before_required_arity.ts | 0 .../fixtures/expect_error_default_parameter_iife_tdz.ts | 0 .../expect_error_default_parameter_invalid_write.ts | 0 .../expect_error_defaulted_before_required_signature.ts | 0 .../tests/fixtures/expect_error_delete_unsupported.ts | 0 .../fixtures/expect_error_destructuring_flow_reset.ts | 0 .../expect_error_destructuring_source_flow_type.ts | 0 ..._error_discriminant_default_keeps_comparable_member.ts | 0 .../fixtures/expect_error_do_while_condition_write.ts | 0 .../fixtures/expect_error_duplicate_type_parameter.ts | 0 .../tests/fixtures/expect_error_empty_array_evolving.ts | 0 .../fixtures/expect_error_enum_member_type_mismatch.ts | 0 .../fixtures/expect_error_enum_switch_on_bare_literals.ts | 0 .../tests/fixtures/expect_error_equality_no_overlap.ts | 0 .../tests/fixtures/expect_error_error_new_method.ts | 0 .../expect_error_exhaustive_switch_leaves_never.ts | 0 .../fixtures/expect_error_exponentiation_asserted.ts | 0 .../tests/fixtures/expect_error_exponentiation_not.ts | 0 .../tests/fixtures/expect_error_exponentiation_plus.ts | 0 .../tests/fixtures/expect_error_exponentiation_typeof.ts | 0 .../tests/fixtures/expect_error_exponentiation_unary.ts | 0 .../tests/fixtures/expect_error_field_does_not_exist.subm | 0 .../fixtures/expect_error_generic_arg_contravariant.ts | 0 .../tests/fixtures/expect_error_generic_arg_supertype.ts | 0 .../tests/fixtures/expect_error_generic_argument_order.ts | 0 .../expect_error_generic_method_argument_order.ts | 0 .../expect_error_generic_type_argument_variance.ts | 0 .../fixtures/expect_error_generic_type_size_limit.ts | 0 .../tests/fixtures/expect_error_getter_needs_return.ts | 0 .../fixtures/expect_error_getter_without_return_type.ts | 0 .../tests/fixtures/expect_error_if_empty_body.ts | 0 .../expect_error_inferred_closure_return_is_widest.ts | 0 ...or_inferred_closure_returns_without_a_covering_type.ts | 0 .../expect_error_inferred_literal_unknown_field.ts | 0 .../fixtures/expect_error_inferred_literal_weak_type.ts | 0 .../fixtures/expect_error_inferred_type_depth_limit.ts | 0 .../expect_error_initializer_captured_mutation.ts | 0 .../tests/fixtures/expect_error_initializer_null.ts | 0 .../tests/fixtures/expect_error_initializer_readonly.ts | 0 .../fixtures/expect_error_interface_to_string_property.ts | 0 .../expect_error_interface_to_string_signature.ts | 0 ...er_module_annotation_error_beside_initializer_error.ts | 0 .../fixtures/expect_error_later_module_const_assigned.ts | 0 .../expect_error_later_module_namespace_read_directly.ts | 0 ..._later_module_variable_annotation_names_later_value.ts | 0 .../expect_error_later_module_variable_inferred_type.ts | 0 .../expect_error_later_module_variable_read_directly.ts | 0 .../tests/fixtures/expect_error_leading_zero_decimal.ts | 0 .../tests/fixtures/expect_error_legacy_octal_literal.ts | 0 .../expect_error_let_keeps_regular_literal_type.ts | 0 .../expect_error_literal_type_number_mismatch.subm | 0 .../expect_error_literal_type_string_mismatch.subm | 0 .../expect_error_lone_surrogate_literal_mismatch.subm | 0 .../tests/fixtures/expect_error_loop_condition_write.ts | 0 .../fixtures/expect_error_loose_nullish_both_sides.ts | 0 .../expect_error_loose_nullish_constant_results.ts | 0 .../expect_error_loose_nullish_effectful_operand.ts | 0 .../expect_error_loose_nullish_effects_and_lines.ts | 0 .../tests/fixtures/expect_error_loose_nullish_equality.ts | 0 .../fixtures/expect_error_loose_nullish_parenthesized.ts | 0 .../tests/fixtures/expect_error_loose_nullish_void.ts | 0 .../tests/fixtures/expect_error_lt_on_boolean.subm | 0 .../fixtures/expect_error_map_for_each_param_types.ts | 0 .../fixtures/expect_error_name_after_decimal_point.ts | 0 .../tests/fixtures/expect_error_nan_comparison.ts | 0 .../fixtures/expect_error_nested_function_duplicate.ts | 0 .../fixtures/expect_error_nested_function_generic.ts | 0 .../expect_error_nested_function_missing_return.ts | 0 .../expect_error_nested_function_outer_narrowing.ts | 0 .../expect_error_nested_function_reads_local_below.ts | 0 .../fixtures/expect_error_nested_function_reassigned.ts | 0 .../expect_error_nested_function_shadows_param.ts | 0 .../tests/fixtures/expect_error_nested_function_this.ts | 0 .../expect_error_nested_function_used_before_capture.ts | 0 ...t_error_nested_function_used_before_sibling_capture.ts | 0 ...sted_function_used_before_sibling_reads_local_below.ts | 0 .../expect_error_nested_function_used_through_alias.ts | 0 .../expect_error_nested_function_write_before_capture.ts | 0 .../expect_error_never_operand_needs_numeric_partner.ts | 0 .../tests/fixtures/expect_error_nullish_mixed_logical.ts | 0 .../fixtures/expect_error_number_plus_string_help.ts | 0 .../tests/fixtures/expect_error_numeric_separator.ts | 0 .../expect_error_object_literal_dictionary_union.ts | 0 .../fixtures/expect_error_object_rest_const_assign.ts | 0 .../expect_error_object_type_construct_signature.ts | 0 .../tests/fixtures/expect_error_optional_chain_limit.ts | 0 .../fixtures/expect_error_optional_chain_missing_key.ts | 0 .../fixtures/expect_error_optional_chain_on_namespace.ts | 0 .../tests/fixtures/expect_error_optional_chain_write.ts | 0 .../expect_error_optional_method_body_direct_call.ts | 0 .../expect_error_optional_method_body_receiver_chain.ts | 0 .../expect_error_optional_method_super_direct_call.ts | 0 .../expect_error_optional_null_field_into_optional.ts | 0 .../fixtures/expect_error_optional_parameter_default.ts | 0 .../expect_error_parameter_modifier_line_break.ts | 0 .../expect_error_parameterless_index_signature.ts | 0 ...expect_error_parenthesized_non_null_keeps_narrowing.ts | 0 ...ect_error_readonly_array_for_mutable_type_parameter.ts | 0 .../tests/fixtures/expect_error_readonly_cast_write.ts | 0 .../tests/fixtures/expect_error_readonly_constructor.ts | 0 .../expect_error_readonly_line_break_class_member.ts | 0 .../expect_error_readonly_line_break_type_member.ts | 0 .../tests/fixtures/expect_error_readonly_method.ts | 0 .../tests/fixtures/expect_error_regex_backreference.subm | 0 .../tests/fixtures/expect_error_regex_duplicate_flag.subm | 0 .../tests/fixtures/expect_error_regex_invalid_flag.subm | 0 .../fixtures/expect_error_regex_invalid_pattern.subm | 0 .../tests/fixtures/expect_error_regex_lookahead.subm | 0 .../tests/fixtures/expect_error_regex_lookbehind.subm | 0 .../tests/fixtures/expect_error_regex_named_backref.subm | 0 .../fixtures/expect_error_regex_negative_lookahead.subm | 0 .../fixtures/expect_error_regex_negative_lookbehind.subm | 0 .../tests/fixtures/expect_error_regex_unterminated.subm | 0 .../expect_error_required_parameter_after_optional.ts | 0 .../tests/fixtures/expect_error_rest_arity_too_few.subm | 0 .../expect_error_rest_callback_for_fixed_arity.ts | 0 .../tests/fixtures/expect_error_rest_no_annotation.subm | 0 .../tests/fixtures/expect_error_rest_non_array.subm | 0 .../tests/fixtures/expect_error_rest_not_last.subm | 0 .../tests/fixtures/expect_error_rest_with_default.subm | 0 .../tests/fixtures/expect_error_runtime_check_limit.ts | 0 .../fixtures/expect_error_runtime_check_locals_limit.ts | 0 .../tests/fixtures/expect_error_spread_fallback_limit.ts | 0 .../expect_error_spread_field_mismatches_interface.ts | 0 .../tests/fixtures/expect_error_spread_null.ts | 0 .../expect_error_spread_of_conditional_widens_field.ts | 0 ...pect_error_spread_optional_field_keeps_earlier_type.ts | 0 .../expect_error_spread_optional_into_required.ts | 0 .../fixtures/expect_error_spread_overwrites_union_tag.ts | 0 .../fixtures/expect_error_spread_union_may_be_empty.ts | 0 .../fixtures/expect_error_strict_mode_reserved_binding.ts | 0 .../tests/fixtures/expect_error_string_at_unnarrowed.ts | 0 .../expect_error_string_or_array_union_method_argument.ts | 0 .../fixtures/expect_error_string_plus_number_help.ts | 0 .../fixtures/expect_error_string_unknown_method.subm | 0 .../tests/fixtures/expect_error_super_conditional.ts | 0 .../fixtures/expect_error_super_in_function_expression.ts | 0 .../fixtures/expect_error_super_in_nested_function.ts | 0 .../tests/fixtures/expect_error_super_misplaced.ts | 0 .../fixtures/expect_error_super_reads_before_call.ts | 0 ...expect_error_switch_case_null_absent_optional_field.ts | 0 ...rror_switch_clause_local_shadows_before_declaration.ts | 0 ...expect_error_switch_clause_reads_other_clause_local.ts | 0 .../expect_error_switch_clause_redeclares_const.ts | 0 .../expect_error_switch_clause_redeclares_function.ts | 0 ..._switch_default_reads_before_later_case_declaration.ts | 0 ...xpect_error_switch_function_uses_other_clause_local.ts | 0 ...xpect_error_switch_later_clause_reads_shadowed_name.ts | 0 ...pect_error_switch_later_clause_writes_shadowed_name.ts | 0 ...t_error_switch_namespace_declared_in_another_clause.ts | 0 .../tests/fixtures/expect_error_syntax_nesting_limit.ts | 0 .../tests/fixtures/expect_error_template_nesting_limit.ts | 0 .../expect_error_temporal_duration_positional_ctor.ts | 0 .../expect_error_temporal_duration_weak_type_number.ts | 0 .../expect_error_this_in_unbound_function_expression.ts | 0 .../fixtures/expect_error_tostring_wrong_signature.subm | 0 .../tests/fixtures/expect_error_tostring_wrong_type.subm | 0 .../tests/fixtures/expect_error_tuple_arity_mismatch.subm | 0 .../tests/fixtures/expect_error_tuple_element_type.subm | 0 .../tests/fixtures/expect_error_tuple_empty_rejected.subm | 0 .../fixtures/expect_error_tuple_index_non_literal.subm | 0 .../tests/fixtures/expect_error_tuple_index_oob.subm | 0 .../tests/fixtures/expect_error_tuple_mutators.ts | 0 .../fixtures/expect_error_tuple_optional_rest_elements.ts | 0 .../tests/fixtures/expect_error_tuple_push.subm | 0 .../tests/fixtures/expect_error_tuple_sort.subm | 0 .../fixtures/expect_error_type_args_after_line_break.ts | 0 .../expect_error_type_declaration_named_like_builtin.ts | 0 .../tests/fixtures/expect_error_type_mismatch.subm | 0 .../tests/fixtures/expect_error_type_nesting_limit.ts | 0 ...ct_error_type_predicate_not_assignable_to_parameter.ts | 0 .../tests/fixtures/expect_error_type_size_limit.ts | 0 .../tests/fixtures/expect_error_typeof_invalid_tag.subm | 0 .../tests/fixtures/expect_error_typeof_of_a_type_name.ts | 0 .../tests/fixtures/expect_error_typeof_unknown_value.ts | 0 .../tests/fixtures/expect_error_unary_minus_string.ts | 0 .../fixtures/expect_error_unary_plus_nullable_string.ts | 0 .../expect_error_unclosed_interface_before_declaration.ts | 0 .../expect_error_unclosed_interface_before_export.ts | 0 ...pect_error_unclosed_type_literal_before_declaration.ts | 0 .../expect_error_undefined_local_const_pattern_write.ts | 0 ...ect_error_undefined_parameter_pattern_literal_write.ts | 0 ..._error_undefined_parameter_property_literal_default.ts | 0 .../expect_error_undefined_tuple_spread_required.ts | 0 .../expect_error_undefined_tuple_spread_required_union.ts | 0 .../expect_error_union_literal_assignment_only.ts | 0 .../fixtures/expect_error_union_literal_unknown_field.ts | 0 .../expect_error_union_literal_unknown_field_tags.ts | 0 .../fixtures/expect_error_visibility_after_readonly.ts | 0 .../fixtures/expect_error_void_compared_with_value.ts | 0 .../tests/fixtures/expect_error_void_condition.ts | 0 .../expect_error_void_conditional_into_value_slot.ts | 0 .../expect_error_void_parameter_default_keeps_void.ts | 0 .../fixtures/expect_error_weak_type_no_common_field.ts | 0 ...expect_warning_nullish_non_null_left_keeps_its_type.ts | 0 .../tests/fixtures/exponentiation_grouping.ts | 0 .../tests/fixtures/field_assignment_flow.ts | 0 .../tests/fixtures/for_of_string_or_array.ts | 0 .../tests/fixtures/fs/absence_probing.ts | 0 .../tests/fixtures/fs/append_text.subm | 0 .../tests/fixtures/fs/bytes_iteration.subm | 0 .../tests/fixtures/fs/bytes_write_read.subm | 0 .../tests/fixtures/fs/copy_creates_destination_parents.ts | 0 .../tests/fixtures/fs/cwd.ts | 0 .../tests/fixtures/fs/exists_size.subm | 0 .../tests/fixtures/fs/info_basic.subm | 0 .../tests/fixtures/fs/linear_remove_move.ts | 0 .../tests/fixtures/fs/lines_break.subm | 0 .../tests/fixtures/fs/lines_iteration.subm | 0 .../tests/fixtures/fs/list_deep.ts | 0 .../tests/fixtures/fs/list_entry_shape.ts | 0 .../tests/fixtures/fs/list_flat.subm | 0 .../tests/fixtures/fs/list_recursive.subm | 0 .../tests/fixtures/fs/many_handles_recovered.subm | 0 .../tests/fixtures/fs/max_read_size.subm | 0 .../tests/fixtures/fs/mkdir_nested.subm | 0 .../tests/fixtures/fs/move_copy_remove.subm | 0 .../tests/fixtures/fs/peek_basic.subm | 0 .../tests/fixtures/fs/peek_crlf.subm | 0 .../tests/fixtures/fs/read_bytes_range.subm | 0 .../tests/fixtures/fs/remove_recursive.subm | 0 .../tests/fixtures/fs/root_is_not_a_target.ts | 0 .../tests/fixtures/fs/stat_kinds.subm | 0 .../tests/fixtures/fs/text_write_read.subm | 0 .../tests/fixtures/fs/writer_basic.subm | 0 .../tests/fixtures/fs/writer_bytes.subm | 0 .../tests/fixtures/function_as_value.subm | 0 .../fixtures/function_identity_cross_package/app/main.ts | 0 .../fixtures/function_identity_cross_package/lib/extra.ts | 0 .../fixtures/function_identity_cross_package/lib/lib.ts | 0 .../fixtures/function_identity_cross_package/mid/lib.ts | 0 .../function_identity_cross_package/packages.manifest | 0 .../tests/fixtures/function_type_rendering_round_trip.ts | 0 .../tests/fixtures/function_type_renders_parseable.ts | 0 .../tests/fixtures/function_typed_array_elements.ts | 0 .../tests/fixtures/generic_arg_accepts_subclass.ts | 0 .../fixtures/generic_call_infers_common_supertype.ts | 0 .../fixtures/generic_call_infers_from_expected_union.ts | 0 .../tests/fixtures/generic_type_argument_variance.ts | 0 .../fixtures/generics/array_push_aliased_function.subm | 0 .../fixtures/generics/array_sort_aliased_object.subm | 0 .../tests/fixtures/generics/call_void_return_type_arg.ts | 0 .../generics/callback_parameter_wider_than_element.ts | 0 .../fixtures/generics/captured_typevar_union_boxed.ts | 0 .../tests/fixtures/generics/class_box_basic.ts | 0 .../tests/fixtures/generics/class_closure_typed_field.ts | 0 .../fixtures/generics/class_cross_package/app/main.ts | 0 .../fixtures/generics/class_cross_package/boxes/lib.ts | 0 .../generics/class_cross_package/packages.manifest | 0 .../generics/class_cross_package_chain/app/main.ts | 0 .../generics/class_cross_package_chain/lib/lib.ts | 0 .../generics/class_cross_package_chain/mid/lib.ts | 0 .../generics/class_cross_package_chain/packages.manifest | 0 .../class_cross_package_closure_member/app/main.ts | 0 .../class_cross_package_closure_member/lib/lib.ts | 0 .../class_cross_package_closure_member/packages.manifest | 0 .../class_cross_package_generic_child/app/main.ts | 0 .../generics/class_cross_package_generic_child/lib/lib.ts | 0 .../class_cross_package_generic_child/packages.manifest | 0 .../class_cross_package_implicit_ctor/app/main.ts | 0 .../class_cross_package_implicit_ctor/base/lib.ts | 0 .../generics/class_cross_package_implicit_ctor/mid/lib.ts | 0 .../class_cross_package_implicit_ctor/packages.manifest | 0 .../generics/class_cross_package_interface/app/main.ts | 0 .../generics/class_cross_package_interface/lib/lib.ts | 0 .../class_cross_package_interface/packages.manifest | 0 .../generics/class_cross_package_namespace/app/main.ts | 0 .../generics/class_cross_package_namespace/lib/lib.ts | 0 .../class_cross_package_namespace/packages.manifest | 0 .../tests/fixtures/generics/class_erased_slot_abi.ts | 0 .../tests/fixtures/generics/class_error_subclass.ts | 0 .../fixtures/generics/class_extends_concrete_args.ts | 0 .../fixtures/generics/class_generic_extends_generic.ts | 0 .../tests/fixtures/generics/class_generic_field_rw.ts | 0 .../generics/class_implements_generic_interface.ts | 0 .../tests/fixtures/generics/class_infer_void_arg.ts | 0 .../tests/fixtures/generics/class_instanceof.ts | 0 .../tests/fixtures/generics/class_instanceof_subclass.ts | 0 .../fixtures/generics/class_object_literal_in_closure.ts | 0 .../tests/fixtures/generics/class_recursive_node.ts | 0 .../fixtures/generics/class_statics_optional_readonly.ts | 0 .../tests/fixtures/generics/class_this_in_closure.ts | 0 .../tests/fixtures/generics/class_two_params.ts | 0 .../tests/fixtures/generics/class_type_arg_shapes.ts | 0 .../generics/class_uninferred_type_param_is_unknown.ts | 0 .../tests/fixtures/generics/class_union_narrowing.ts | 0 .../tests/fixtures/generics/class_universal_slots.ts | 0 .../tests/fixtures/generics/class_void_type_arg.ts | 0 .../fixtures/generics/expect_error_arithmetic_on_t.subm | 0 .../fixtures/generics/expect_error_arity_mismatch.subm | 0 ...ct_error_callback_base_class_with_unbound_arguments.ts | 0 .../fixtures/generics/expect_error_class_arg_mismatch.ts | 0 .../fixtures/generics/expect_error_class_extends_arity.ts | 0 .../fixtures/generics/expect_error_class_generic_arity.ts | 0 .../generics/expect_error_class_implements_wrong_arg.ts | 0 .../generics/expect_error_class_instanceof_alias.ts | 0 .../generics/expect_error_class_instanceof_args.ts | 0 .../generics/expect_error_class_instanceof_impossible.ts | 0 .../generics/expect_error_class_method_generic.ts | 0 .../generics/expect_error_class_never_type_arg.ts | 0 .../generics/expect_error_class_static_type_param.ts | 0 .../generics/expect_error_concrete_into_generic_call.subm | 0 .../generics/expect_error_conflicting_bindings.subm | 0 .../generics/expect_error_cross_gp_assignment.subm | 0 .../fixtures/generics/expect_error_ctor_void_type_arg.ts | 0 .../generics/expect_error_first_class_generic.subm | 0 .../expect_error_generic_call_common_supertype.ts | 0 .../expect_error_generic_call_keeps_regular_literal.ts | 0 .../expect_error_generic_method_interface_literal.ts | 0 ...r_generic_object_argument_plain_value_keeps_literal.ts | 0 .../expect_error_generic_object_argument_slot_mismatch.ts | 0 .../expect_error_generic_variance_chain_back_to_root.ts | 0 ...xpect_error_generic_variance_growing_instantiations.ts | 0 .../generics/expect_error_inference_argument_priority.ts | 0 .../fixtures/generics/expect_error_interface_arity.subm | 0 .../generics/expect_error_method_never_type_arg.ts | 0 .../expect_error_recursion_assigns_concrete_to_t.subm | 0 .../generics/expect_error_recursion_returns_concrete.subm | 0 .../expect_error_uninferred_type_param_is_unknown.ts | 0 .../generics/expect_error_union_member_closely_matched.ts | 0 .../tests/fixtures/generics/explicit_type_args.subm | 0 .../tests/fixtures/generics/first.subm | 0 .../generics/generic_call_infers_from_nested_literals.ts | 0 .../fixtures/generics/generic_call_keeps_literal_type.ts | 0 .../generic_call_literal_candidates_form_union.ts | 0 .../generics/generic_call_nested_literal_arguments.ts | 0 .../generic_call_result_keeps_declared_literals.ts | 0 .../generics/generic_call_widens_fresh_literal.ts | 0 .../tests/fixtures/generics/generic_calls_generic.subm | 0 .../generic_covariant_void_argument_compares_members.ts | 0 .../fixtures/generics/generic_interface_annotation.subm | 0 ...generic_object_argument_infers_callback_fields_last.ts | 0 .../fixtures/generics/generic_object_round_trip.subm | 0 .../tests/fixtures/generics/generic_recursion.subm | 0 ...generic_result_literal_freshness_per_type_parameter.ts | 0 .../generic_tuple_argument_infers_elements_in_order.ts | 0 ...neric_union_parameter_infers_from_structured_member.ts | 0 .../generics/generic_union_parameter_naked_priority.ts | 0 .../fixtures/generics/generic_variance_measured_once.ts | 0 .../tests/fixtures/generics/identity.subm | 0 ...nference_through_interfaces_fields_and_nested_calls.ts | 0 .../tests/fixtures/generics/map_set_aliased_value.subm | 0 .../generics/nullish_candidates_infer_their_union.ts | 0 .../generics/object_literal_for_generic_interface.ts | 0 .../tests/fixtures/generics/recursion.subm | 0 .../tests/fixtures/generics/returns_generic_closure.subm | 0 .../tests/fixtures/generics/tostring_on_t.subm | 0 .../tests/fixtures/generics/tuple_return_generic_fn.ts | 0 .../generics/uninferred_type_param_is_unknown.subm | 0 .../generics/union_parameter_takes_what_others_leave.ts | 0 .../tests/fixtures/generics/unknown_runtime_descriptor.ts | 0 .../tests/fixtures/global_array_object_literal.subm | 0 .../tests/fixtures/higher_order_function.subm | 0 .../tests/fixtures/higher_order_no_literal.ts | 0 .../tests/fixtures/higher_order_with_capture.subm | 0 .../tests/fixtures/host_error_catchable.subm | 0 .../tests/fixtures/host_held_values_survive_collection.ts | 0 .../tests/fixtures/host_owned_vtables.ts | 0 .../tests/fixtures/host_string_struct_spike.ts | 0 .../errors/expect_error_download_options_extra_field.subm | 0 .../http/errors/expect_error_get_too_many_args.subm | 0 .../fixtures/http/errors/expect_error_get_with_body.subm | 0 .../http/errors/expect_error_headers_wrong_type.subm | 0 .../errors/expect_error_headers_wrong_value_type.subm | 0 .../http/errors/expect_error_post_body_wrong_type.subm | 0 .../http/errors/expect_error_response_unknown_method.subm | 0 .../errors/expect_error_response_unknown_property.subm | 0 .../tests/fixtures/http_dot_segments.ts | 0 .../tests/fixtures/imports/alias_named_from.ts | 0 .../imports/ancestor_only_static_closure/app/main.ts | 0 .../imports/ancestor_only_static_closure/lib/lib.ts | 0 .../ancestor_only_static_closure/packages.manifest | 0 .../tests/fixtures/imports/embedding_aliased.ts | 0 .../tests/fixtures/imports/embedding_named.ts | 0 .../tests/fixtures/imports/embedding_namespace.ts | 0 .../fixtures/imports/embedding_wildcard_namespace.ts | 0 .../fixtures/imports/errors/combined_default_named.subm | 0 .../tests/fixtures/imports/errors/duplicate_local.subm | 0 .../errors/expect_error_prelude_namespace_aliased.subm | 0 .../expect_error_prelude_namespace_star_aliased.subm | 0 .../tests/fixtures/imports/errors/export_default.subm | 0 .../imports/errors/export_inside_function_body.subm | 0 .../tests/fixtures/imports/errors/export_list.subm | 0 .../tests/fixtures/imports/errors/import_in_function.subm | 0 .../tests/fixtures/imports/errors/namespace_as_value.subm | 0 .../imports/errors/namespace_member_as_value.subm | 0 .../imports/errors/relative_import_escapes_root.subm | 0 .../imports/errors/relative_import_single_file.subm | 0 .../tests/fixtures/imports/errors/unknown_named.subm | 0 .../fixtures/imports/errors/unknown_namespace_member.subm | 0 .../tests/fixtures/imports/errors/unknown_package.subm | 0 .../imports/errors/uuid_namespace_not_auto_imported.subm | 0 .../fixtures/imports/errors/uuid_not_auto_imported.subm | 0 .../tests/fixtures/imports/export_modifier_ignored.subm | 0 .../fixtures/imports/http_namespace_optional_args.subm | 0 .../imports/import_prelude_namespace_forgiven.subm | 0 .../imports/import_prelude_namespace_star_forgiven.subm | 0 .../tests/fixtures/imports/llm_aliased.ts | 0 .../tests/fixtures/imports/llm_named.ts | 0 .../tests/fixtures/imports/llm_namespace.ts | 0 .../tests/fixtures/imports/llm_package_caller/app/main.ts | 0 .../fixtures/imports/llm_package_caller/packages.manifest | 0 .../fixtures/imports/llm_package_caller/triage/lib.ts | 0 .../tests/fixtures/imports/llm_wildcard_namespace.ts | 0 .../tests/fixtures/imports/security_check_basic.subm | 0 .../fixtures/imports/security_check_chain/app/main.ts | 0 .../fixtures/imports/security_check_chain/inner/lib.ts | 0 .../fixtures/imports/security_check_chain/outer/lib.ts | 0 .../imports/security_check_chain/packages.manifest | 0 .../imports/security_check_closure_callback/app/main.ts | 0 .../imports/security_check_closure_callback/inner/lib.ts | 0 .../imports/security_check_closure_callback/outer/lib.ts | 0 .../security_check_closure_callback/packages.manifest | 0 .../tests/fixtures/imports/security_check_denied.ts | 0 .../tests/fixtures/imports/security_check_namespace.subm | 0 .../tests/fixtures/imports/session_aliased.ts | 0 .../tests/fixtures/imports/session_named.ts | 0 .../tests/fixtures/imports/session_namespace.ts | 0 .../fixtures/imports/session_package_caller/app/main.ts | 0 .../imports/session_package_caller/packages.manifest | 0 .../fixtures/imports/session_package_caller/store/lib.ts | 0 .../tests/fixtures/imports/session_wildcard_namespace.ts | 0 .../tests/fixtures/imports/uuid_aliased.subm | 0 .../tests/fixtures/imports/uuid_named.subm | 0 .../tests/fixtures/imports/uuid_namespace.subm | 0 .../tests/fixtures/imports/uuid_v7.subm | 0 .../tests/fixtures/imports/uuid_wildcard_namespace.subm | 0 .../tests/fixtures/inferred_closure_return_widening.ts | 0 .../tests/fixtures/inferred_literal_extra_fields.ts | 0 .../tests/fixtures/infinity_nan_parameter_defaults.ts | 0 .../tests/fixtures/inherited_method_lift_substitutes.ts | 0 .../tests/fixtures/initializer_narrowing.ts | 0 .../tests/fixtures/initializer_union_shapes.ts | 0 .../tests/fixtures/interface_to_string.ts | 0 .../tests/fixtures/interface_value_capture.subm | 0 .../interface_value_into_nullable_object_return.ts | 0 .../tests/fixtures/interface_value_into_object_slot.ts | 0 .../fixtures/interfaces/expansive_recursive_assign.ts | 0 .../interfaces/expect_error_bad_member_separator.ts | 0 .../expect_error_expansive_recursive_mismatch.ts | 0 .../interfaces/expect_error_finite_recursive_mismatch.ts | 0 .../expect_error_method_interface_from_object.subm | 0 .../expect_error_user_interface_missing_member.subm | 0 .../expect_error_user_interface_missing_method.subm | 0 .../expect_error_user_interface_wrong_method_type.subm | 0 .../fixtures/interfaces/interface_property_no_literal.ts | 0 .../tests/fixtures/interfaces/single_line_members.ts | 0 .../interfaces/structural_object_interface_assign.subm | 0 .../interfaces/user_interface_decl_typechecks.subm | 0 .../tests/fixtures/interfaces/user_interface_factory.subm | 0 .../fixtures/interfaces/user_interface_nested_field.subm | 0 .../fixtures/interfaces/user_interface_property_read.subm | 0 .../interfaces/user_interface_value_method_call.subm | 0 .../tests/fixtures/is_array.subm | 0 .../tests/fixtures/is_primitive.subm | 0 .../tests/fixtures/issue_1147_array_capacity.ts | 0 .../tests/fixtures/issue_1147_push_compatibility.ts | 0 .../tests/fixtures/issue_821/functions.ts | 0 .../tests/fixtures/issue_821/optional_functions.ts | 0 .../tests/fixtures/issue_821/top_level_function.ts | 0 .../tests/fixtures/issue_831/cycles.ts | 0 .../tests/fixtures/issue_831/mixed_cycles.ts | 0 .../tests/fixtures/issue_836/number_format.ts | 0 .../tests/fixtures/issue_844/null_algebra.ts | 0 .../tests/fixtures/issue_844/null_keys.ts | 0 .../tests/fixtures/issue_872/array_discriminant.ts | 0 .../tests/fixtures/issue_872/array_guard_boundaries.ts | 0 .../fixtures/issue_899/expect_error_distinct_enums.ts | 0 .../tests/fixtures/issue_899/primitive_enum.ts | 0 .../tests/fixtures/issue_965/global_call_reassignment.ts | 0 .../tests/fixtures/issue_966/insert_optional.ts | 0 .../tests/fixtures/issue_966/inserted_fields_json.ts | 0 .../tests/fixtures/issue_966/insertion_during_write.ts | 0 .../fixtures/issue_966/insertion_preserves_guards.ts | 0 .../tests/fixtures/issue_968/conditional_loop_writes.ts | 0 .../tests/fixtures/issue_968/nested_loop_writes.ts | 0 .../tests/fixtures/issue_970/accessor_enumeration.ts | 0 .../issue_regressions/compound_literal_operands.ts | 0 .../issue_regressions/conditional_literal_results.ts | 0 .../tests/fixtures/issue_regressions/disjunction_guard.ts | 0 .../fixtures/issue_regressions/enum_literal_equality.ts | 0 ...expect_error_compound_assign_receiver_reported_once.ts | 0 .../expect_error_conditional_spread_type.ts | 0 .../expect_error_disjoint_literal_equality.ts | 0 .../issue_regressions/expect_error_disjunction_partial.ts | 0 .../expect_error_explicit_void_return.ts | 0 .../expect_error_finally_break_missing_return.ts | 0 .../expect_error_literal_false_branch.ts | 0 .../expect_error_missing_prelude_members.ts | 0 .../expect_error_negative_literal_equality.ts | 0 .../expect_error_nested_finally_break.ts | 0 .../issue_regressions/expect_error_nested_switch_break.ts | 0 .../expect_error_optional_spread_type.ts | 0 .../expect_error_polymorphic_contravariance.ts | 0 .../expect_error_polymorphic_mismatch.ts | 0 .../issue_regressions/expect_error_switch_try_falls.ts | 0 .../fixtures/issue_regressions/finally_break_return.ts | 0 .../fixtures/issue_regressions/finite_alias_depth.ts | 0 .../tests/fixtures/issue_regressions/literal_equality.ts | 0 .../issue_regressions/literal_equality_aliases.ts | 0 .../fixtures/issue_regressions/logical_interpolation.ts | 0 .../issue_regressions/nested_polymorphic_alias.ts | 0 .../tests/fixtures/issue_regressions/nullable_equality.ts | 0 .../tests/fixtures/issue_regressions/object_spread.ts | 0 .../issue_regressions/object_spread_integration.ts | 0 .../fixtures/issue_regressions/object_spread_overrides.ts | 0 .../fixtures/issue_regressions/object_spread_presence.ts | 0 .../fixtures/issue_regressions/polymorphic_covariance.ts | 0 .../fixtures/issue_regressions/signed_literal_equality.ts | 0 .../fixtures/issue_regressions/switch_try_termination.ts | 0 .../tests/fixtures/issue_regressions/void_callback.ts | 0 .../tests/fixtures/iterators/close_called_on_break.subm | 0 .../fixtures/iterators/close_called_on_exhaustion.subm | 0 .../tests/fixtures/iterators/close_called_on_throw.subm | 0 .../iterators/iterable_each_loop_closes_own_cursor.subm | 0 .../tests/fixtures/iterators/iterable_hand_rolled.subm | 0 .../tests/fixtures/iterators/iterator_break.subm | 0 .../tests/fixtures/iterators/iterator_continue.subm | 0 .../tests/fixtures/iterators/iterator_hand_rolled.subm | 0 .../tests/fixtures/iterators/iterator_nullable_t.subm | 0 .../tests/fixtures/iterators/no_close_no_crash.subm | 0 .../tests/fixtures/iterators/user_interface_iterable.subm | 0 .../tests/fixtures/json/expect_error_bare_json.subm | 0 .../tests/fixtures/json/expect_error_let_json_parse.subm | 0 .../fixtures/json/expect_error_parse_function_target.subm | 0 .../json/expect_error_parse_too_many_type_args.subm | 0 .../json/expect_error_parse_type_args_and_as.subm | 0 .../json/expect_error_parse_uint8array_target.subm | 0 .../tests/fixtures/json/expect_error_partial_json.subm | 0 .../fixtures/json/expect_error_stringify_replacer.ts | 0 .../fixtures/json/expect_error_stringify_type_args.subm | 0 .../json/expect_error_to_json_wrong_signature.subm | 0 .../fixtures/json/expect_error_to_json_wrong_type.subm | 0 .../fixtures/json/expect_error_unknown_json_member.subm | 0 .../tests/fixtures/json/interface_optional_omitted.ts | 0 .../tests/fixtures/json/main_array_return.subm | 0 .../tests/fixtures/json/main_object_return.subm | 0 .../tests/fixtures/json/parse_array_of_literal.subm | 0 .../tests/fixtures/json/parse_array_of_numbers.subm | 0 .../tests/fixtures/json/parse_array_of_objects.subm | 0 .../tests/fixtures/json/parse_array_of_strings.subm | 0 .../tests/fixtures/json/parse_array_of_tuples.subm | 0 .../tests/fixtures/json/parse_array_of_union.subm | 0 .../tests/fixtures/json/parse_as_cast.subm | 0 .../tests/fixtures/json/parse_bool.subm | 0 .../fixtures/json/parse_diagnostic_preview_path.subm | 0 .../tests/fixtures/json/parse_explicit_generic.subm | 0 .../tests/fixtures/json/parse_field_union.subm | 0 .../tests/fixtures/json/parse_inferred_interface.ts | 0 .../tests/fixtures/json/parse_into_generic_interface.subm | 0 .../tests/fixtures/json/parse_into_interface.subm | 0 .../tests/fixtures/json/parse_into_interface_nested.subm | 0 .../fixtures/json/parse_into_recursive_interface.subm | 0 .../tests/fixtures/json/parse_invalid_throws.subm | 0 .../tests/fixtures/json/parse_mismatch_throws.subm | 0 .../tests/fixtures/json/parse_nested.subm | 0 .../tests/fixtures/json/parse_null.subm | 0 .../tests/fixtures/json/parse_number.subm | 0 .../tests/fixtures/json/parse_number_literal_target.subm | 0 .../tests/fixtures/json/parse_object_equals_hash.subm | 0 .../tests/fixtures/json/parse_object_lenient.subm | 0 .../tests/fixtures/json/parse_object_literal_field.subm | 0 .../tests/fixtures/json/parse_object_nullable_field.subm | 0 .../tests/fixtures/json/parse_object_optional_field.subm | 0 .../tests/fixtures/json/parse_object_round_trip.subm | 0 .../tests/fixtures/json/parse_object_simple.subm | 0 .../fixtures/json/parse_recursive_discriminated.subm | 0 .../tests/fixtures/json/parse_recursive_linked_list.subm | 0 .../tests/fixtures/json/parse_recursive_object.subm | 0 .../tests/fixtures/json/parse_recursive_union.subm | 0 .../tests/fixtures/json/parse_string.subm | 0 .../tests/fixtures/json/parse_string_literal_target.subm | 0 .../tests/fixtures/json/parse_t_or_null.subm | 0 .../tests/fixtures/json/parse_tuple_basic.subm | 0 .../tests/fixtures/json/parse_tuple_in_object.subm | 0 .../tests/fixtures/json/parse_tuple_literal_position.subm | 0 .../tests/fixtures/json/parse_tuple_nested.subm | 0 .../tests/fixtures/json/parse_tuple_round_trip.subm | 0 .../tests/fixtures/json/parse_union_literal_set.subm | 0 .../tests/fixtures/json/parse_union_mixed_tags.subm | 0 .../tests/fixtures/json/parse_union_primitive.subm | 0 .../tests/fixtures/json/parse_union_shared_tag.subm | 0 .../tests/fixtures/json/parse_union_status_code.subm | 0 .../tests/fixtures/json/parse_union_tagged.subm | 0 .../tests/fixtures/json/parse_union_untagged.subm | 0 .../tests/fixtures/json/stringify_array.subm | 0 .../tests/fixtures/json/stringify_as_string.subm | 0 .../tests/fixtures/json/stringify_bool.subm | 0 .../json/stringify_interface_array_round_trip.subm | 0 .../json/stringify_interface_optional_field_assigned.ts | 0 .../tests/fixtures/json/stringify_negative_zero.subm | 0 .../tests/fixtures/json/stringify_null.subm | 0 .../json/stringify_null_valued_nullable_field.subm | 0 .../tests/fixtures/json/stringify_nullable_number.subm | 0 .../tests/fixtures/json/stringify_nullable_object.subm | 0 .../tests/fixtures/json/stringify_nullable_string.subm | 0 .../tests/fixtures/json/stringify_number.subm | 0 .../tests/fixtures/json/stringify_object.subm | 0 .../fixtures/json/stringify_object_optional_field.subm | 0 .../tests/fixtures/json/stringify_pretty_eval_order.ts | 0 .../tests/fixtures/json/stringify_pretty_space_number.ts | 0 .../tests/fixtures/json/stringify_pretty_space_string.ts | 0 .../tests/fixtures/json/stringify_string.subm | 0 .../tests/fixtures/json/to_json_direct.subm | 0 .../tests/fixtures/json/to_json_field_override.subm | 0 .../json/to_json_field_override_with_capture.subm | 0 .../tests/fixtures/json/to_json_via_generic.subm | 0 .../tests/fixtures/json_parse_lone_surrogate.ts | 0 .../tests/fixtures/json_stringify_collection.ts | 0 .../tests/fixtures/json_stringify_erased_null.ts | 0 .../tests/fixtures/json_stringify_reassigned_field.ts | 0 .../tests/fixtures/json_stringify_width_subtype.ts | 0 .../tests/fixtures/json_utf16_lossless.ts | 0 .../fixtures/later_module_variable_shadows_namespace.ts | 0 .../tests/fixtures/let_keeps_regular_literal_types.ts | 0 .../tests/fixtures/linear_regex_output.ts | 0 .../tests/fixtures/linear_string_transforms.ts | 0 .../tests/fixtures/literal_keeping_operators.ts | 0 .../fixtures/literal_own_type_keeps_binding_writable.ts | 0 .../tests/fixtures/literal_own_type_under_annotation.ts | 0 .../tests/fixtures/literal_type_capture.subm | 0 .../tests/fixtures/literal_type_number.subm | 0 .../tests/fixtures/literal_type_string.subm | 0 .../tests/fixtures/literal_type_union.subm | 0 .../tests/fixtures/literal_union_interface_field.ts | 0 .../tests/fixtures/llm_basic.ts | 0 .../tests/fixtures/llm_batch_ordering.ts | 0 .../tests/fixtures/llm_batch_partial_failure.ts | 0 .../tests/fixtures/llm_budget_aggregate.ts | 0 .../tests/fixtures/llm_budget_per_execution.ts | 0 .../tests/fixtures/llm_budget_release_after_trap.ts | 0 .../tests/fixtures/llm_call_erased.ts | 0 .../tests/fixtures/llm_call_unknown.ts | 0 .../tests/fixtures/llm_denied.ts | 0 .../tests/fixtures/llm_error_taxonomy.ts | 0 .../tests/fixtures/llm_models_all_callable.ts | 0 .../tests/fixtures/llm_models_empty.ts | 0 .../tests/fixtures/llm_models_filtered.ts | 0 .../tests/fixtures/llm_models_no_description.ts | 0 .../tests/fixtures/llm_no_provider.ts | 0 .../tests/fixtures/llm_prompt_bounds.ts | 0 .../tests/fixtures/llm_schema_argument_rejected.ts | 0 .../tests/fixtures/llm_schema_unsupported.ts | 0 .../tests/fixtures/llm_typed_get.ts | 0 .../tests/fixtures/llm_typed_mismatch.ts | 0 .../tests/fixtures/llm_typed_provider_ignored_schema.ts | 0 .../tests/fixtures/loop_condition_write_narrows.ts | 0 .../tests/fixtures/loop_empty_body.ts | 0 .../fixtures/loops/body_scope_vs_synthesized_stmts.ts | 0 .../tests/fixtures/loops/do_while_break.subm | 0 .../tests/fixtures/loops/do_while_continue.ts | 0 .../tests/fixtures/loops/do_while_once.subm | 0 .../tests/fixtures/loops/do_while_truthiness_cond.subm | 0 .../loops/errors/expect_error_break_outside_loop.subm | 0 .../loops/errors/expect_error_continue_outside_loop.subm | 0 .../loops/errors/expect_error_for_of_non_array.subm | 0 .../tests/fixtures/loops/for_basic.subm | 0 .../tests/fixtures/loops/for_break.subm | 0 .../tests/fixtures/loops/for_continue.subm | 0 .../tests/fixtures/loops/for_empty_slots.subm | 0 .../tests/fixtures/loops/for_let_per_iteration_binding.ts | 0 .../tests/fixtures/loops/for_nested.subm | 0 .../tests/fixtures/loops/for_of_break.subm | 0 .../tests/fixtures/loops/for_of_continue.subm | 0 .../tests/fixtures/loops/for_of_empty.subm | 0 .../tests/fixtures/loops/for_of_number_array.subm | 0 .../tests/fixtures/loops/for_of_string_array.subm | 0 .../tests/fixtures/loops/for_of_tuple.ts | 0 .../tests/fixtures/loops/for_truthiness_cond.subm | 0 .../tests/fixtures/map_for_each.subm | 0 .../tests/fixtures/map_from_differing_tuple_literals.ts | 0 .../tests/fixtures/map_set_from_iterable.ts | 0 .../tests/fixtures/map_set_identity.ts | 0 .../tests/fixtures/maps/basic_string_keys.subm | 0 .../tests/fixtures/maps/cached_hashes_and_ledger.ts | 0 .../tests/fixtures/maps/ctor_from_entries.subm | 0 .../fixtures/maps/expect_error_for_of_non_iterable.subm | 0 .../tests/fixtures/maps/expect_error_record_type.ts | 0 .../tests/fixtures/maps/expect_error_weakmap_type.subm | 0 .../tests/fixtures/maps/expect_error_weakmap_value.subm | 0 .../tests/fixtures/maps/expect_error_weakset_type.subm | 0 .../tests/fixtures/maps/expect_error_weakset_value.subm | 0 .../tests/fixtures/maps/host_port_roundtrip.ts | 0 .../tests/fixtures/maps/insertion_order.subm | 0 .../tests/fixtures/maps/insertion_order_after_resize.subm | 0 .../fixtures/maps/insertion_order_delete_middle.subm | 0 .../tests/fixtures/maps/insertion_order_set.subm | 0 .../fixtures/maps/insertion_order_set_after_resize.subm | 0 .../fixtures/maps/insertion_order_set_delete_middle.subm | 0 .../tests/fixtures/maps/iterate_for_of.subm | 0 .../tests/fixtures/maps/iterate_iterator_method.subm | 0 .../tests/fixtures/maps/iterate_set_iterator_method.subm | 0 .../tests/fixtures/maps/iterator_concurrent.subm | 0 .../tests/fixtures/maps/iterator_sees_later_sets.subm | 0 .../fixtures/maps/keys_values_entries_iterators.subm | 0 .../tests/fixtures/maps/number_keys.subm | 0 .../tests/fixtures/maps/object_keys.subm | 0 .../fixtures/maps/object_values_get_field_access.subm | 0 .../tests/fixtures/maps/phase2_typecheck.subm | 0 .../tests/fixtures/maps/phase6_for_of_typecheck.subm | 0 .../tests/fixtures/maps/postfix_chain_on_new.subm | 0 .../tests/fixtures/maps/resize.subm | 0 .../tests/fixtures/maps/set_basic.subm | 0 .../tests/fixtures/maps/set_ctor_from_values.subm | 0 .../tests/fixtures/maps/set_host_port_roundtrip.ts | 0 .../tests/fixtures/maps/set_iterate.subm | 0 .../fixtures/maps/set_keys_values_entries_iterators.subm | 0 .../tests/fixtures/maps/tombstone_reclamation.ts | 0 .../tests/fixtures/maps/tombstone_reuse.subm | 0 .../tests/fixtures/math_basic.subm | 0 .../tests/fixtures/math_constants.subm | 0 .../tests/fixtures/math_hypot.subm | 0 .../tests/fixtures/math_pi.subm | 0 .../tests/fixtures/math_random.subm | 0 .../tests/fixtures/math_transcendentals.subm | 0 .../tests/fixtures/method_call_through_string_key.ts | 0 .../fixtures/method_lift_substitutes_receiver_args.ts | 0 .../module_let_narrowing_reads_live_after_call.ts | 0 .../fixtures/module_variable_before_initialization.ts | 0 .../tests/fixtures/multi/aliased_enum_import/lib.ts | 0 .../tests/fixtures/multi/aliased_enum_import/m_enum.ts | 0 .../fixtures/multi/default_param_cross_module/lib.ts | 0 .../fixtures/multi/default_param_cross_module/util.ts | 0 .../tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts | 0 .../fixtures/multi/errors/ambiguous_ts_subm/wrap.subm | 0 .../tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts | 0 .../tests/fixtures/multi/errors/cycle/b.subm | 0 .../tests/fixtures/multi/errors/cycle/lib.subm | 0 .../tests/fixtures/multi/errors/main_decl/lib.subm | 0 .../tests/fixtures/multi/errors/missing_module/lib.subm | 0 .../errors/module_exported_function_private_type/lib.subm | 0 .../module_exported_function_private_type/util.subm | 0 .../errors/module_exported_global_private_type/lib.subm | 0 .../errors/module_exported_global_private_type/util.subm | 0 .../errors/module_exported_type_private_type/lib.subm | 0 .../errors/module_exported_type_private_type/util.subm | 0 .../package_exported_function_private_type/lib.subm | 0 .../package_exported_function_private_type/util.subm | 0 .../errors/package_exported_type_private_type/lib.subm | 0 .../errors/package_exported_type_private_type/util.subm | 0 .../lib.subm | 0 .../util.subm | 0 .../lib.subm | 0 .../util.subm | 0 .../tests/fixtures/multi/errors/private_symbol/lib.subm | 0 .../tests/fixtures/multi/errors/private_symbol/util.subm | 0 .../fixtures/multi/exported_docs_direct_documented/lib.ts | 0 .../fixtures/multi/exported_docs_direct_missing/lib.ts | 0 .../fixtures/multi/exported_docs_interface_member/lib.ts | 0 .../fixtures/multi/exported_docs_internal_helper/lib.ts | 0 .../fixtures/multi/exported_docs_reexport_missing/lib.ts | 0 .../fixtures/multi/exported_docs_reexport_missing/util.ts | 0 .../fixtures/multi/exported_docs_sibling_only/lib.ts | 0 .../fixtures/multi/exported_docs_sibling_only/util.ts | 0 .../multi/exported_function_type_surface/lib.subm | 0 .../multi/exported_function_type_surface/util.subm | 0 .../tests/fixtures/multi/namespace_import/lib.subm | 0 .../tests/fixtures/multi/namespace_import/util.subm | 0 .../package_reexported_recursive_type_surface/lib.subm | 0 .../package_reexported_recursive_type_surface/util.subm | 0 .../tests/fixtures/multi/reexport_basic/lib.subm | 0 .../tests/fixtures/multi/reexport_basic/util.subm | 0 .../fixtures/multi/reserved_word_export_names/lib.ts | 0 .../fixtures/multi/reserved_word_export_names/values.ts | 0 .../tests/fixtures/multi/sibling_import/lib.subm | 0 .../tests/fixtures/multi/sibling_import/util.subm | 0 .../multi/signature_lift_unimported_receiver_type/lib.ts | 0 .../signature_lift_unimported_receiver_type/widget.ts | 0 .../tests/fixtures/multi/ts_mixed/lib.ts | 0 .../tests/fixtures/multi/ts_mixed/wrap.subm | 0 .../tests/fixtures/multi/type_only_reexport/lib.ts | 0 .../tests/fixtures/multi/type_only_reexport/util.ts | 0 .../multi/union_write_help_unimported_member/lib.ts | 0 .../multi/union_write_help_unimported_member/widget.ts | 0 .../tests/fixtures/mvp_greet.subm | 0 .../tests/fixtures/namespace_shadowed_by_top_level.ts | 0 .../tests/fixtures/nan_local_binding_not_flagged.ts | 0 .../tests/fixtures/narrowed_boxed_binding_read.ts | 0 .../tests/fixtures/narrowing/aliased_conditions_narrow.ts | 0 .../tests/fixtures/narrowing/array_isarray_narrows.subm | 0 .../fixtures/narrowing/array_isarray_on_generic.subm | 0 .../fixtures/narrowing/assign_narrow_then_rewiden.ts | 0 .../fixtures/narrowing/assign_narrowing_survives_join.ts | 0 .../fixtures/narrowing/assign_narrows_block_tail.subm | 0 .../fixtures/narrowing/assign_sibling_invalidates.subm | 0 .../fixtures/narrowing/assign_then_call_invalidates.subm | 0 .../fixtures/narrowing/assignment_value_truthiness.ts | 0 .../narrowing/back_edge_narrowing_not_at_entry.ts | 0 .../narrowing/call_preserves_identifier_narrowing.subm | 0 .../narrowing/call_preserves_property_path_narrowing.subm | 0 .../tests/fixtures/narrowing/call_rereads_field_path.ts | 0 .../fixtures/narrowing/captured_mutator_write_back.ts | 0 .../tests/fixtures/narrowing/chained_short_circuit.subm | 0 .../tests/fixtures/narrowing/class_field_and_chain.ts | 0 .../tests/fixtures/narrowing/class_field_nested_if.ts | 0 .../fixtures/narrowing/class_private_field_same_module.ts | 0 .../tests/fixtures/narrowing/closure_last_assignment.ts | 0 .../fixtures/narrowing/closure_reguards_field_path.ts | 0 .../narrowing/computed_write_retains_literal_type.ts | 0 .../narrowing/const_narrow_closure_for_of_const.ts | 0 .../narrowing/const_narrow_closure_nested_arrow.ts | 0 .../narrowing/const_narrow_closure_param_shadow.ts | 0 .../narrowing/const_narrow_closure_returns_later.ts | 0 .../fixtures/narrowing/const_narrow_closure_top_level.ts | 0 .../narrowing/const_narrow_closure_typeof_unknown.ts | 0 .../fixtures/narrowing/const_narrow_survives_closure.ts | 0 .../fixtures/narrowing/discriminant_kind_equality.subm | 0 .../fixtures/narrowing/discriminant_kind_inequality.subm | 0 .../tests/fixtures/narrowing/discriminant_member_sets.ts | 0 .../fixtures/narrowing/discriminant_three_variants.subm | 0 .../fixtures/narrowing/do_while_back_edge_wraps_body.ts | 0 .../tests/fixtures/narrowing/dropped_index_path_hint.ts | 0 .../tests/fixtures/narrowing/enum_discriminant_case.ts | 0 .../enum_exclusions_reach_switch_and_predicate.ts | 0 .../narrowing/enum_exclusions_survive_other_checks.ts | 0 .../narrowing/enum_tuple_and_variable_discriminants.ts | 0 .../tests/fixtures/narrowing/equality_between_unions.ts | 0 .../exhaustive_switch_after_stale_narrowing_throws.ts | 0 ...ct_error_aliased_condition_needs_constant_reference.ts | 0 .../narrowing/expect_error_assign_narrowing_leaves_try.ts | 0 .../expect_error_assignment_narrow_in_closure.ts | 0 .../expect_error_assignment_value_truthiness_rules_out.ts | 0 .../expect_error_back_edge_narrowing_at_entry.ts | 0 .../narrowing/expect_error_captured_mutating_let.subm | 0 .../expect_error_computed_key_guard_written_by_name.ts | 0 .../expect_error_destructured_parameter_reassigned.ts | 0 .../narrowing/expect_error_do_while_continue_widens.ts | 0 .../expect_error_enum_exclusions_keep_unchecked_member.ts | 0 .../expect_error_equal_to_type_parameter_keeps_null.ts | 0 .../expect_error_equality_keeps_overlapping_objects.ts | 0 .../expect_error_field_path_narrow_in_closure.ts | 0 ...rror_field_with_every_member_ruled_out_is_not_never.ts | 0 .../fixtures/narrowing/expect_error_flow_catch_throw.ts | 0 .../narrowing/expect_error_flow_continue_write.ts | 0 .../fixtures/narrowing/expect_error_flow_field_do.ts | 0 .../fixtures/narrowing/expect_error_flow_field_for.ts | 0 .../fixtures/narrowing/expect_error_flow_field_forof.ts | 0 .../fixtures/narrowing/expect_error_flow_field_while.ts | 0 .../fixtures/narrowing/expect_error_flow_finally_break.ts | 0 .../fixtures/narrowing/expect_error_flow_local_direct.ts | 0 .../fixtures/narrowing/expect_error_flow_local_nested.ts | 0 .../fixtures/narrowing/expect_error_flow_local_switch.ts | 0 .../fixtures/narrowing/expect_error_flow_local_try.ts | 0 .../narrowing/expect_error_flow_root_reassignment.ts | 0 .../tests/fixtures/narrowing/expect_error_flow_update.ts | 0 .../narrowing/expect_error_flow_zero_reachable_do.ts | 0 .../narrowing/expect_error_flow_zero_reachable_for.ts | 0 .../narrowing/expect_error_flow_zero_reachable_forof.ts | 0 .../narrowing/expect_error_flow_zero_reachable_while.ts | 0 .../narrowing/expect_error_for_update_continue_widens.ts | 0 .../expect_error_function_union_assignment_short_call.ts | 0 .../expect_error_generic_member_is_not_a_discriminant.ts | 0 .../tests/fixtures/narrowing/expect_error_getter_path.ts | 0 .../fixtures/narrowing/expect_error_getter_path_cast.ts | 0 .../fixtures/narrowing/expect_error_getter_path_index.ts | 0 .../fixtures/narrowing/expect_error_getter_path_prefix.ts | 0 .../narrowing/expect_error_in_operator_primitive_rhs.subm | 0 .../narrowing/expect_error_index_by_changing_key.ts | 0 .../narrowing/expect_error_let_narrow_in_closure.ts | 0 .../expect_error_missing_return_in_narrow_region.subm | 0 .../expect_error_module_let_written_by_function.ts | 0 .../narrowing/expect_error_more_narrowing_hints.ts | 0 .../expect_error_never_array_element_keeps_its_type.ts | 0 .../narrowing/expect_error_nominal_union_reads.ts | 0 .../fixtures/narrowing/expect_error_nullable_rw_target.ts | 0 .../narrowing/expect_error_operator_narrowing_hint.ts | 0 .../narrowing/expect_error_param_narrow_in_closure.ts | 0 ...xpect_error_property_path_field_write_invalidates.subm | 0 .../expect_error_reassign_same_type_kills_guard.ts | 0 .../expect_error_rejected_write_keeps_declared_type.ts | 0 .../expect_error_switch_last_clause_runs_off_end.ts | 0 .../expect_error_switch_no_match_exit_narrows.ts | 0 .../expect_error_unreachable_code_reads_declared_types.ts | 0 .../expect_error_unreachable_in_narrow_region.subm | 0 .../narrowing/expect_error_user_guard_body_unsound.subm | 0 .../expect_error_user_guard_generic_unsound.subm | 0 .../narrowing/expect_error_user_guard_in_alias.subm | 0 .../narrowing/expect_error_user_guard_not_param.subm | 0 .../expect_error_user_guard_type_alias_unsound.subm | 0 .../expect_error_write_still_invalidates_after_call.subm | 0 .../fixtures/narrowing/field_path_two_deep_structural.ts | 0 .../tests/fixtures/narrowing/flow_clause_joins.ts | 0 .../tests/fixtures/narrowing/flow_condition_preserved.ts | 0 .../tests/fixtures/narrowing/flow_do_break.ts | 0 .../fixtures/narrowing/flow_for_condition_preserved.ts | 0 .../tests/fixtures/narrowing/flow_join_820.ts | 0 .../tests/fixtures/narrowing/flow_join_898.ts | 0 .../tests/fixtures/narrowing/flow_join_901.ts | 0 .../tests/fixtures/narrowing/flow_join_902.ts | 0 .../tests/fixtures/narrowing/flow_loops.ts | 0 .../tests/fixtures/narrowing/flow_numeric_source.ts | 0 .../tests/fixtures/narrowing/flow_switch_unmatched.ts | 0 .../tests/fixtures/narrowing/flow_this_for.ts | 0 .../fixtures/narrowing/for_cond_narrow_wraps_body.ts | 0 .../narrowing/for_loop_mutated_let_null_guard_number.subm | 0 .../narrowing/for_loop_mutated_let_null_guard_string.subm | 0 .../fixtures/narrowing/for_of_back_edge_wraps_body.ts | 0 .../narrowing/for_of_body_local_continue_narrow.ts | 0 .../fixtures/narrowing/for_of_loop_var_continue_narrow.ts | 0 .../fixtures/narrowing/for_update_runs_on_back_edge.ts | 0 .../tests/fixtures/narrowing/function_union_assignment.ts | 0 .../tests/fixtures/narrowing/generic_class_box_of_box.ts | 0 .../tests/fixtures/narrowing/global_field_paths.ts | 0 .../tests/fixtures/narrowing/global_guard_mutation.ts | 0 .../tests/fixtures/narrowing/global_ternary_null.ts | 0 .../tests/fixtures/narrowing/guard_through_an_element.ts | 0 .../fixtures/narrowing/immediately_invoked_functions.ts | 0 .../fixtures/narrowing/in_operator_basic_object.subm | 0 .../tests/fixtures/narrowing/in_operator_dynamic_key.ts | 0 .../fixtures/narrowing/in_operator_union_filter.subm | 0 .../fixtures/narrowing/in_operator_unknown_chain.subm | 0 .../tests/fixtures/narrowing/in_typeof_field_chain.subm | 0 .../tests/fixtures/narrowing/index_by_constant_key.ts | 0 .../tests/fixtures/narrowing/index_path_and_chain.ts | 0 .../fixtures/narrowing/interface_field_holding_class.ts | 0 .../tests/fixtures/narrowing/issue_785_chain.ts | 0 .../narrowing/issue_785_expect_error_null_chain.ts | 0 .../tests/fixtures/narrowing/issue_785_switch.ts | 0 .../tests/fixtures/narrowing/issue_786.ts | 0 .../fixtures/narrowing/issue_786_expect_error_shadow.ts | 0 .../tests/fixtures/narrowing/issue_816.ts | 0 .../tests/fixtures/narrowing/issue_889.ts | 0 .../narrowing/issue_889_expect_error_arrow_guard.ts | 0 .../tests/fixtures/narrowing/issue_890_anonymous_lift.ts | 0 .../tests/fixtures/narrowing/issue_890_predicate_lift.ts | 0 .../tests/fixtures/narrowing/issue_929.ts | 0 .../fixtures/narrowing/issue_929_expect_error_union.ts | 0 .../tests/fixtures/narrowing/issue_948.ts | 0 .../tests/fixtures/narrowing/issue_948_composed.ts | 0 .../tests/fixtures/narrowing/issue_948_discriminant.ts | 0 .../tests/fixtures/narrowing/issue_948_nested.ts | 0 .../tests/fixtures/narrowing/issue_948_switch.ts | 0 .../tests/fixtures/narrowing/issue_948_union_refined.ts | 0 .../fixtures/narrowing/join_points_keep_narrowing.ts | 0 .../narrowing/literal_equality_chain_rules_out.ts | 0 .../narrowing/literal_equality_excludes_nullish.ts | 0 .../tests/fixtures/narrowing/literal_index_guard.ts | 0 .../tests/fixtures/narrowing/live_assignment_result.ts | 0 .../tests/fixtures/narrowing/live_big_bom.ts | 0 .../tests/fixtures/narrowing/live_big_separator.ts | 0 .../fixtures/narrowing/live_boolean_literal_result.ts | 0 .../tests/fixtures/narrowing/live_call_order.ts | 0 .../tests/fixtures/narrowing/live_function_reference.ts | 0 .../tests/fixtures/narrowing/live_index_conversion.ts | 0 .../tests/fixtures/narrowing/live_index_noncanonical.ts | 0 .../tests/fixtures/narrowing/live_json_arguments.ts | 0 .../tests/fixtures/narrowing/live_map_return.ts | 0 .../tests/fixtures/narrowing/live_member_builtin_rest.ts | 0 .../tests/fixtures/narrowing/live_member_class_rest.ts | 0 .../tests/fixtures/narrowing/live_member_default.ts | 0 .../tests/fixtures/narrowing/live_member_fresh_default.ts | 0 .../fixtures/narrowing/live_member_function_default.ts | 0 .../tests/fixtures/narrowing/live_member_rest.ts | 0 .../tests/fixtures/narrowing/live_number_predicate.ts | 0 .../fixtures/narrowing/live_optional_shape_analysis.ts | 0 .../narrowing/live_package_array_argument/app/main.ts | 0 .../narrowing/live_package_array_argument/library/lib.ts | 0 .../live_package_array_argument/packages.manifest | 0 .../narrowing/live_package_callback_parameter/app/main.ts | 0 .../live_package_callback_parameter/library/lib.ts | 0 .../live_package_callback_parameter/packages.manifest | 0 .../narrowing/live_package_function_reference/app/main.ts | 0 .../live_package_function_reference/library/lib.ts | 0 .../live_package_function_reference/packages.manifest | 0 .../narrowing/live_package_imported_global/app/main.ts | 0 .../narrowing/live_package_imported_global/library/lib.ts | 0 .../live_package_imported_global/packages.manifest | 0 .../narrowing/live_package_object_argument/app/main.ts | 0 .../narrowing/live_package_object_argument/library/lib.ts | 0 .../live_package_object_argument/packages.manifest | 0 .../narrowing/live_package_returned_closure/app/main.ts | 0 .../live_package_returned_closure/library/lib.ts | 0 .../live_package_returned_closure/packages.manifest | 0 .../narrowing/live_package_setter_parameter/app/main.ts | 0 .../live_package_setter_parameter/library/lib.ts | 0 .../live_package_setter_parameter/packages.manifest | 0 .../tests/fixtures/narrowing/live_postfix_value.ts | 0 .../tests/fixtures/narrowing/live_pow_boundary.ts | 0 .../tests/fixtures/narrowing/live_pow_nan.ts | 0 .../tests/fixtures/narrowing/live_receiver_generic.ts | 0 .../tests/fixtures/narrowing/live_receiver_includes.ts | 0 .../tests/fixtures/narrowing/live_receiver_length.ts | 0 .../tests/fixtures/narrowing/live_receiver_method.ts | 0 .../tests/fixtures/narrowing/live_receiver_optional.ts | 0 .../tests/fixtures/narrowing/live_receiver_to_string.ts | 0 .../tests/fixtures/narrowing/live_regex_argument.ts | 0 .../tests/fixtures/narrowing/live_runtime_values.ts | 0 .../tests/fixtures/narrowing/live_search_order.ts | 0 .../tests/fixtures/narrowing/live_string_argument.ts | 0 .../tests/fixtures/narrowing/live_valueof_conversion.ts | 0 .../fixtures/narrowing/live_values_packages/app/main.ts | 0 .../narrowing/live_values_packages/library/lib.ts | 0 .../narrowing/live_values_packages/packages.manifest | 0 .../tests/fixtures/narrowing/loop_exit_body_local_join.ts | 0 .../loop_head_keeps_narrowing_when_body_returns.ts | 0 .../tests/fixtures/narrowing/loop_join_after_continue.ts | 0 .../tests/fixtures/narrowing/loop_tail_narrowings.ts | 0 .../tests/fixtures/narrowing/loop_wrapped_body_forms.ts | 0 .../fixtures/narrowing/mixed_union_typeof_plus_kind.subm | 0 ...le_let_written_by_function_narrows_within_statement.ts | 0 .../tests/fixtures/narrowing/nested_block_narrowing.subm | 0 .../tests/fixtures/narrowing/nested_shadow_reuse.ts | 0 .../narrowing/never_array_hints_later_elements.ts | 0 .../fixtures/narrowing/never_field_in_object_literal.ts | 0 .../fixtures/narrowing/never_operand_in_dead_code.ts | 0 .../tests/fixtures/narrowing/never_read_in_closure.ts | 0 .../fixtures/narrowing/nominal_union_field_access.ts | 0 .../tests/fixtures/narrowing/non_null_assertion.ts | 0 .../narrowing/non_null_receiver_preserves_path.ts | 0 .../tests/fixtures/narrowing/not_truthiness_narrow.subm | 0 .../tests/fixtures/narrowing/null_comparison_guards.ts | 0 .../tests/fixtures/narrowing/null_eq_else.subm | 0 .../tests/fixtures/narrowing/null_global_narrow.subm | 0 .../tests/fixtures/narrowing/null_neq_then.subm | 0 .../tests/fixtures/narrowing/null_neq_unbox.subm | 0 .../fixtures/narrowing/nullable_rw_target_write_out.ts | 0 .../tests/fixtures/narrowing/nullable_smoke.subm | 0 .../tests/fixtures/narrowing/operator_narrowing.ts | 0 .../narrowing/optional_field_eq_null_post_if.subm | 0 .../narrowing/optional_field_neq_null_narrows.subm | 0 .../tests/fixtures/narrowing/postfix_narrowed.ts | 0 .../fixtures/narrowing/property_path_chained_post_if.subm | 0 .../narrowing/property_path_discriminant_post_if.subm | 0 .../property_path_discriminant_three_variants.subm | 0 .../property_path_discriminant_view_on_field.subm | 0 .../tests/fixtures/narrowing/property_path_eq_else.subm | 0 .../tests/fixtures/narrowing/property_path_neq_then.subm | 0 .../narrowing/property_path_neq_then_post_if.subm | 0 .../fixtures/narrowing/reassign_same_type_rewidens.ts | 0 .../fixtures/narrowing/return_in_if_carries_narrow.subm | 0 .../tests/fixtures/narrowing/rules_out_every_value.ts | 0 .../fixtures/narrowing/short_circuit_and_narrows.subm | 0 .../fixtures/narrowing/short_circuit_or_narrows.subm | 0 .../fixtures/narrowing/sibling_paths_mixed_chain_len.ts | 0 .../fixtures/narrowing/sibling_paths_three_idents.ts | 0 .../fixtures/narrowing/switch_boolean_discriminant.ts | 0 .../narrowing/switch_default_reads_never_on_any_path.ts | 0 .../narrowing/switch_wide_discriminant_falls_through.ts | 0 .../narrowing/switch_without_default_falls_through.ts | 0 .../fixtures/narrowing/ternary_and_interface_field.ts | 0 .../tests/fixtures/narrowing/this_rooted_paths.ts | 0 .../fixtures/narrowing/throw_in_if_carries_narrow.subm | 0 .../fixtures/narrowing/truthiness_field_path_narrow.subm | 0 .../tests/fixtures/narrowing/truthiness_narrow.subm | 0 .../narrowing/tuple_union_literal_discriminator.subm | 0 .../narrowing/tuple_union_typeof_discriminator.subm | 0 .../tests/fixtures/narrowing/typeof_aliased_union.subm | 0 .../tests/fixtures/narrowing/typeof_boolean_narrow.subm | 0 .../fixtures/narrowing/typeof_field_path_else_branch.subm | 0 .../fixtures/narrowing/typeof_field_path_string.subm | 0 .../narrowing/typeof_folded_operand_still_runs.ts | 0 .../tests/fixtures/narrowing/typeof_function_generic.subm | 0 .../tests/fixtures/narrowing/typeof_function_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_number_narrow.subm | 0 .../fixtures/narrowing/typeof_object_and_enum_tags.ts | 0 .../tests/fixtures/narrowing/typeof_object_generic.subm | 0 .../tests/fixtures/narrowing/typeof_object_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_string_narrow.subm | 0 .../tests/fixtures/narrowing/typeof_three_way_union.subm | 0 .../fixtures/narrowing/typeof_through_generic_alias.ts | 0 .../tests/fixtures/narrowing/user_guard_discriminant.subm | 0 .../tests/fixtures/narrowing/user_guard_else_branch.subm | 0 .../user_guard_generic_non_generic_asserted.subm | 0 .../fixtures/narrowing/user_guard_generic_strip_null.subm | 0 .../tests/fixtures/narrowing/user_guard_in_typeof.subm | 0 .../tests/fixtures/narrowing/user_guard_nullable.subm | 0 .../tests/fixtures/narrowing/user_guard_primitive.subm | 0 .../tests/fixtures/narrowing/user_guard_type_alias.subm | 0 .../narrowing/while_body_local_continue_narrow.ts | 0 .../tests/fixtures/narrowing/while_body_narrowing.subm | 0 .../fixtures/narrowing/while_break_carries_narrow.subm | 0 .../fixtures/narrowing/while_break_two_paths_widens.subm | 0 .../fixtures/narrowing/while_fixed_point_continue.subm | 0 .../fixtures/narrowing/while_fixed_point_converges.subm | 0 .../tests/fixtures/narrowing_field_path_nested_region.ts | 0 .../tests/fixtures/nested_function_default_param.ts | 0 .../tests/fixtures/nested_function_reads_later_local.ts | 0 .../tests/fixtures/nested_function_top_level_block.ts | 0 .../fixtures/never/expect_error_never_falls_through.subm | 0 .../never/expect_error_return_value_in_never_fn.subm | 0 .../never/expect_error_value_into_never_slot.subm | 0 .../tests/fixtures/never/never_assignable_to_string.subm | 0 .../tests/fixtures/never/never_in_union.subm | 0 .../tests/fixtures/never/never_return_throw.subm | 0 .../fixtures/never_annotated_closure_in_void_slot.ts | 0 .../tests/fixtures/never_function_void_slot.ts | 0 .../tests/fixtures/never_generic_callback.ts | 0 .../tests/fixtures/never_operands.ts | 0 .../tests/fixtures/new_uint8array.subm | 0 .../tests/fixtures/new_with_dotted_form.subm | 0 .../tests/fixtures/no_panic_prelude_invariants.ts | 0 .../non_null_assert_on_null_narrowing_reads_declared.ts | 0 .../tests/fixtures/null_discriminant_narrows.ts | 0 .../tests/fixtures/nullable_receiver_names_the_guard.ts | 0 .../tests/fixtures/nullish_coalescing/chained.subm | 0 .../nullish_coalescing/coalesce_null_typed_left.ts | 0 .../nullish_coalescing/expect_error_mix_with_and.subm | 0 .../nullish_coalescing/expect_error_mix_with_or.subm | 0 .../tests/fixtures/nullish_coalescing/simple.subm | 0 .../tests/fixtures/nullish_coalescing/void_right.ts | 0 .../tests/fixtures/nullish_coalescing/with_field.subm | 0 .../tests/fixtures/nullish_coalescing/with_parens_ok.subm | 0 .../tests/fixtures/nullish_grouping_and_zero_literals.ts | 0 .../tests/fixtures/number_global_predicates.subm | 0 .../tests/fixtures/number_parse_statics.subm | 0 .../tests/fixtures/number_predicates_no_coercion.ts | 0 .../tests/fixtures/number_radix_strings.subm | 0 .../tests/fixtures/number_static_constants.subm | 0 .../tests/fixtures/number_static_predicates.subm | 0 .../tests/fixtures/number_to_fixed.subm | 0 .../tests/fixtures/number_to_precision_exponential.subm | 0 .../tests/fixtures/number_to_string_radix.subm | 0 .../fixtures/numeric_separators_and_decimal_point.ts | 0 .../tests/fixtures/object_function_typed_field.subm | 0 .../tests/fixtures/object_is.subm | 0 .../tests/fixtures/object_key_reassigned_wider_field.ts | 0 .../tests/fixtures/object_literal_dictionary_union.ts | 0 .../tests/fixtures/object_literal_evaluation_order.ts | 0 .../fixtures/object_literal_into_nullable_tagged_union.ts | 0 .../fixtures/object_literal_normalization_at_depth.ts | 0 .../tests/fixtures/object_literal_subtype_reduction.ts | 0 .../tests/fixtures/object_rest_copies.ts | 0 .../tests/fixtures/object_rest_let.ts | 0 .../tests/fixtures/object_spread_widened_union.ts | 0 .../tests/fixtures/object_statics.subm | 0 .../tests/fixtures/object_statics_host.ts | 0 .../tests/fixtures/object_type_member_named_new.ts | 0 .../absent_optional_property_with_sibling_accessor.ts | 0 .../objects/expect_error_field_assign_missing_field.subm | 0 .../objects/expect_error_field_assign_non_object.subm | 0 .../objects/expect_error_field_assign_type_mismatch.subm | 0 .../expect_error_fresh_literal_extra_annotated.subm | 0 .../objects/expect_error_fresh_literal_extra_return.subm | 0 .../objects/expect_error_invalid_assign_target.subm | 0 .../expect_error_optional_not_assignable_to_required.subm | 0 ...t_error_optional_not_assignable_to_value_nullable.subm | 0 .../objects/expect_error_union_missing_field.subm | 0 .../expect_error_unknown_string_bracket_field.subm | 0 ...t_error_value_nullable_not_assignable_to_optional.subm | 0 .../tests/fixtures/objects/field_assign_basic.subm | 0 .../fixtures/objects/field_assign_const_binding.subm | 0 .../tests/fixtures/objects/field_assign_nested.subm | 0 .../tests/fixtures/objects/field_assign_string.subm | 0 .../tests/fixtures/objects/interface_field_assignment.ts | 0 .../fixtures/objects/interface_property_write_dispatch.ts | 0 .../tests/fixtures/objects/multiline_object_literal.subm | 0 .../tests/fixtures/objects/nullable_eq_literal.subm | 0 .../tests/fixtures/objects/nullable_field_literal.subm | 0 .../tests/fixtures/objects/optional_field_literal.subm | 0 .../fixtures/objects/optional_field_null_compare.subm | 0 .../tests/fixtures/objects/optional_present_null.ts | 0 .../tests/fixtures/objects/optional_undefined_presence.ts | 0 .../tests/fixtures/objects/property_shorthand.subm | 0 .../tests/fixtures/objects/quoted_property_names.subm | 0 .../fixtures/objects/reserved_keyword_property_names.subm | 0 .../tests/fixtures/objects/union_field_access.subm | 0 .../tests/fixtures/objects/widen_to_nullable_field.subm | 0 .../tests/fixtures/objects/width_sub_array.subm | 0 .../tests/fixtures/objects/width_sub_assign.subm | 0 .../tests/fixtures/objects/width_sub_basic.subm | 0 .../fixtures/objects/width_sub_intermediate_arg.subm | 0 .../tests/fixtures/objects/width_sub_nested.subm | 0 .../tests/fixtures/optional_chain_near_limit.ts | 0 .../fixtures/optional_chain_non_nullable_receiver.ts | 0 .../fixtures/optional_chain_nullable_host_property.ts | 0 .../tests/fixtures/optional_chain_string_key.ts | 0 .../optional_chaining/chain_nullable_step_fixes.ts | 0 .../fixtures/optional_chaining/chain_then_coalesce.subm | 0 .../optional_chaining/expect_error_chain_nullable_step.ts | 0 .../expect_error_optional_call_binding.ts | 0 .../expect_error_optional_method_reference.ts | 0 .../expect_error_optional_null_receiver.ts | 0 .../expect_error_optional_unknown_receiver.ts | 0 .../tests/fixtures/optional_chaining/field_chain.subm | 0 .../fixtures/optional_chaining/multiple_optional.subm | 0 .../fixtures/optional_chaining/nested_field_chain.subm | 0 .../tests/fixtures/optional_chaining/non_null_division.ts | 0 .../fixtures/optional_chaining/non_null_void_result.ts | 0 .../tests/fixtures/optional_chaining/optional_call.subm | 0 .../optional_chaining/optional_call_defaults_and_rest.ts | 0 .../optional_chaining/optional_call_nullable_return.ts | 0 .../fixtures/optional_chaining/optional_class_accessor.ts | 0 .../fixtures/optional_chaining/optional_class_field.ts | 0 .../optional_chaining/optional_class_field_chain.ts | 0 .../fixtures/optional_chaining/optional_generic_method.ts | 0 .../tests/fixtures/optional_chaining/optional_index.subm | 0 .../fixtures/optional_chaining/optional_index_bounds.ts | 0 .../optional_chaining/optional_inherited_field.ts | 0 .../optional_chaining/optional_interface_accessor.ts | 0 .../optional_chaining/optional_interface_property.subm | 0 .../tests/fixtures/optional_chaining/optional_method.subm | 0 .../optional_chaining/optional_method_nullable_return.ts | 0 .../fixtures/optional_chaining/optional_narrowed_step.ts | 0 .../optional_chaining/optional_non_null_continuation.ts | 0 .../optional_chaining/optional_object_prelude_member.ts | 0 .../optional_chaining/optional_primitive_receiver.ts | 0 .../optional_chaining/optional_redundant_primitive.ts | 0 .../fixtures/optional_chaining/optional_union_field.ts | 0 .../fixtures/optional_chaining/optional_void_method.subm | 0 .../fixtures/optional_chaining/void_result_bindings.ts | 0 .../fixtures/optional_field_written_null_serializes.ts | 0 .../tests/fixtures/optional_to_json_property.ts | 0 .../tests/fixtures/optional_to_string_property.ts | 0 .../fixtures/override_narrows_return_with_finally.ts | 0 .../tests/fixtures/override_returns_into_narrower_slot.ts | 0 .../tests/fixtures/override_slot_variance.ts | 0 .../fixtures/override_variance_cross_package/app/main.ts | 0 .../fixtures/override_variance_cross_package/base/lib.ts | 0 .../fixtures/override_variance_cross_package/child/lib.ts | 0 .../override_variance_cross_package/packages.manifest | 0 .../fixtures/package_rules/capability_binding_key/lib.ts | 0 .../package_rules/capability_binding_paths_resolve/lib.ts | 0 .../capability_binding_paths_resolve/types.ts | 0 .../fixtures/package_rules/capability_dynamic_name/lib.ts | 0 .../fixtures/package_rules/capability_extra_tag/lib.ts | 0 .../fixtures/package_rules/capability_missing_tag/lib.ts | 0 .../package_rules/capability_nonliteral_payload/lib.ts | 0 .../fixtures/package_rules/capability_payload_key/lib.ts | 0 .../package_rules/capability_unknown_field/lib.ts | 0 .../package_rules/capability_unknown_field/types.ts | 0 .../package_rules/capability_unknown_parameter/lib.ts | 0 .../fixtures/package_rules/class_member_bodies/lib.ts | 0 .../fixtures/package_rules/class_missing_return/lib.ts | 0 .../package_rules/class_switch_fallthrough/lib.ts | 0 .../fixtures/package_rules/class_unreachable_code/lib.ts | 0 .../fixtures/package_rules/doc_callable_members/lib.ts | 0 .../tests/fixtures/package_rules/doc_consistency/lib.ts | 0 .../package_rules/enum_dependency_exhaustive/app/main.ts | 0 .../enum_dependency_exhaustive/consumer/lib.ts | 0 .../enum_dependency_exhaustive/levels/lib.ts | 0 .../enum_dependency_exhaustive/packages.manifest | 0 .../package_rules/enum_other_module_exhaustive/levels.ts | 0 .../package_rules/enum_other_module_exhaustive/lib.ts | 0 .../package_rules/enum_other_module_exhaustive/shades.ts | 0 .../tests/fixtures/package_rules/missing_return/lib.ts | 0 .../fixtures/package_rules/switch_fallthrough/lib.ts | 0 .../tests/fixtures/package_rules/top_level_return/lib.ts | 0 .../fixtures/package_rules/unassigned_class_field/lib.ts | 0 .../tests/fixtures/package_rules/unreachable_code/lib.ts | 0 .../class_member_object_literal_cross_package/app/main.ts | 0 .../class_member_object_literal_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../packages/closure_param_cross_package/app/main.ts | 0 .../packages/closure_param_cross_package/host/lib.ts | 0 .../closure_param_cross_package/packages.manifest | 0 .../closure_sig_inherited_from_dependency/app/main.ts | 0 .../closure_sig_inherited_from_dependency/base/lib.ts | 0 .../packages.manifest | 0 .../fixtures/packages/const_ref_cross_package/app/main.ts | 0 .../fixtures/packages/const_ref_cross_package/cfg/lib.ts | 0 .../packages/const_ref_cross_package/packages.manifest | 0 .../interface_dispatch_in_declaring_package/app/main.ts | 0 .../interface_dispatch_in_declaring_package/lib/lib.ts | 0 .../packages.manifest | 0 .../packages/recursive_alias_cross_package/app/main.ts | 0 .../packages/recursive_alias_cross_package/lib/lib.ts | 0 .../recursive_alias_cross_package/packages.manifest | 0 .../parameter_defaults_reference_earlier_parameters.ts | 0 .../fixtures/parameter_literal_union_default_write.ts | 0 .../tests/fixtures/parse_int_radix_undefined.ts | 0 .../tests/fixtures/postfix_incdec/inc_dec_basic.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_bigint.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_captured.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_field.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_for_loop.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_global.subm | 0 .../fixtures/postfix_incdec/inc_dec_in_expression.subm | 0 .../tests/fixtures/postfix_incdec/inc_dec_index.subm | 0 .../property_regressions/expect_error_in_nullable.ts | 0 .../expect_error_inherited_write_only.ts | 0 .../expect_error_optional_write_only.ts | 0 .../expect_error_write_only_assignment.ts | 0 .../expect_error_write_only_implements.ts | 0 .../tests/fixtures/property_regressions/in_accessors.ts | 0 .../fixtures/property_regressions/in_erased_presence.ts | 0 .../tests/fixtures/property_regressions/in_presence.ts | 0 .../fixtures/property_regressions/inherited_accessors.ts | 0 .../property_regressions/interface_json_surrogates.ts | 0 .../fixtures/property_regressions/interface_postfix.ts | 0 .../property_regressions/interface_wide_mutation.ts | 0 .../property_regressions/postfix_package/app/main.ts | 0 .../property_regressions/postfix_package/lib/lib.ts | 0 .../postfix_package/packages.manifest | 0 .../fixtures/property_regressions/recursive_mutation.ts | 0 .../property_regressions/required_undefined_round_trip.ts | 0 .../fixtures/property_regressions/required_unknown.ts | 0 .../tests/fixtures/radix_number_literals.subm | 0 .../fixtures/readonly/assignment_narrows_to_value_type.ts | 0 .../readonly/expect_error_readonly_array_writes.ts | 0 .../expect_error_readonly_field_shown_in_object_type.ts | 0 .../fixtures/readonly/expect_error_readonly_non_array.ts | 0 .../readonly/expect_error_readonly_survives_narrowing.ts | 0 .../expect_error_readonly_survives_value_shape.ts | 0 .../fixtures/readonly/expect_error_readonly_to_mutable.ts | 0 .../readonly/getonly_cannot_implement_writable.ts | 0 .../tests/fixtures/readonly/inline_object_runtime.ts | 0 .../readonly/interface_property_write_rejected.ts | 0 .../readonly/object_type_property_write_rejected.ts | 0 .../tests/fixtures/readonly/readonly_array_reads.ts | 0 .../tests/fixtures/readonly/writable_property_write_ok.ts | 0 .../tests/fixtures/readonly_cast_qualifiers.ts | 0 .../tests/fixtures/readonly_rest_parameter.ts | 0 .../tests/fixtures/readonly_rest_parameter_write.ts | 0 .../tests/fixtures/readonly_string_length.subm | 0 .../tests/fixtures/records/cross_package/app/main.ts | 0 .../tests/fixtures/records/cross_package/lib/lib.ts | 0 .../fixtures/records/cross_package/packages.manifest | 0 .../tests/fixtures/records/indexed_growth_and_equality.ts | 0 .../tests/fixtures/records/optional_dynamic_presence.ts | 0 .../tests/fixtures/records/record_accessors.ts | 0 .../tests/fixtures/records/record_bad_computed_spread.ts | 0 .../tests/fixtures/records/record_basic.ts | 0 .../tests/fixtures/records/record_checked_reads.ts | 0 .../tests/fixtures/records/record_class_guards.ts | 0 .../tests/fixtures/records/record_conditional_spread.ts | 0 .../tests/fixtures/records/record_errors.ts | 0 .../tests/fixtures/records/record_evaluation.ts | 0 .../tests/fixtures/records/record_features.ts | 0 .../tests/fixtures/records/record_forward_index.ts | 0 .../tests/fixtures/records/record_function_receiver.ts | 0 .../fixtures/records/record_generic_contract_errors.ts | 0 .../fixtures/records/record_generic_method_errors.ts | 0 .../tests/fixtures/records/record_generic_methods.ts | 0 .../tests/fixtures/records/record_inherit_composition.ts | 0 .../fixtures/records/record_inherit_composition_errors.ts | 0 .../tests/fixtures/records/record_inherit_conflicts.ts | 0 .../fixtures/records/record_inherit_forward_alias.ts | 0 .../tests/fixtures/records/record_inherit_members.ts | 0 .../tests/fixtures/records/record_inherit_narrow.ts | 0 .../tests/fixtures/records/record_interface_reads.ts | 0 .../tests/fixtures/records/record_literal_writes.ts | 0 .../tests/fixtures/records/record_postfix_checked.ts | 0 .../tests/fixtures/records/record_recursive.ts | 0 .../fixtures/records/record_recursive_interface_error.ts | 0 .../tests/fixtures/records/record_structural_write.ts | 0 .../tests/fixtures/records/record_unions.ts | 0 .../tests/fixtures/recursive-types/alias_linked_list.subm | 0 .../recursive-types/alias_polymorphic_recursion.ts | 0 .../tests/fixtures/recursive-types/alias_through_array.ts | 0 .../recursive-types/alias_through_generic_call.ts | 0 .../tests/fixtures/recursive-types/alias_tree.subm | 0 .../tests/fixtures/recursive-types/alias_union_json.subm | 0 .../fixtures/recursive-types/interface_resolution.subm | 0 .../tests/fixtures/regex_exec_basic.subm | 0 .../tests/fixtures/regex_flags_all.subm | 0 .../tests/fixtures/regex_input_cache.ts | 0 .../tests/fixtures/regex_lastindex_non_global.subm | 0 .../tests/fixtures/regex_lastindex_sticky.subm | 0 .../tests/fixtures/regex_literal_basic.subm | 0 .../tests/fixtures/regex_named_captures.subm | 0 .../tests/fixtures/regex_named_captures_unmatched.ts | 0 .../tests/fixtures/regex_non_ascii_literal.ts | 0 .../tests/fixtures/regex_numbered_captures.subm | 0 .../tests/fixtures/regex_per_site_lastindex.subm | 0 .../tests/fixtures/regex_property_reads.subm | 0 .../tests/fixtures/regex_shared_input.ts | 0 .../tests/fixtures/regex_test_basic.subm | 0 .../tests/fixtures/regex_test_lastindex_global.subm | 0 .../tests/fixtures/regex_to_string.subm | 0 .../tests/fixtures/regex_utf16_offsets.ts | 0 .../tests/fixtures/regexp_invalid_flags_type.ts | 0 .../fixtures/regexp_match_keeps_lone_surrogates.subm | 0 .../tests/fixtures/regexp_missing_source.ts | 0 .../tests/fixtures/regexp_optional_flags.ts | 0 .../tests/fixtures/regexp_replace_split_match_js.ts | 0 .../tests/fixtures/regexp_shorthand_classes_match_js.ts | 0 .../regexp_split_unmatched_capture_is_undefined.ts | 0 .../tests/fixtures/rejected_field_write_rhs_hint.ts | 0 .../tests/fixtures/rest_callback_for_fixed_arity.ts | 0 .../tests/fixtures/rest_param_arrow.subm | 0 .../tests/fixtures/rest_param_basic.subm | 0 .../tests/fixtures/rest_param_generic.subm | 0 .../tests/fixtures/rest_param_mixed.subm | 0 .../tests/fixtures/return_paths_void_union_and_getters.ts | 0 .../tests/fixtures/secrets_main_denied.ts | 0 .../tests/fixtures/session_basic.ts | 0 .../tests/fixtures/session_cursor_length_budget.ts | 0 .../tests/fixtures/session_denied.ts | 0 .../tests/fixtures/session_get_erased.ts | 0 .../tests/fixtures/session_get_mismatch.ts | 0 .../tests/fixtures/session_get_unknown.ts | 0 .../tests/fixtures/session_list.ts | 0 .../tests/fixtures/session_list_cursor_is_sealed.ts | 0 .../tests/fixtures/session_list_filtered.ts | 0 .../tests/fixtures/session_remove_denied.ts | 0 .../tests/fixtures/session_surrogate_fidelity.ts | 0 .../tests/fixtures/session_typed_get.ts | 0 .../tests/fixtures/session_unsupported_value.ts | 0 .../tests/fixtures/set_algebra.subm | 0 .../tests/fixtures/set_iteration_parity.subm | 0 .../tests/fixtures/set_relations.subm | 0 .../tests/fixtures/shared_serializer_buffer.ts | 0 .../tests/fixtures/spread/array_basic.subm | 0 .../tests/fixtures/spread/array_empty_source.subm | 0 .../tests/fixtures/spread/array_only_spreads.subm | 0 .../spread/err_array_spread_element_mismatch.subm | 0 .../tests/fixtures/spread/err_array_spread_non_array.subm | 0 .../fixtures/spread/err_object_spread_interface.subm | 0 .../fixtures/spread/err_object_spread_non_object.subm | 0 .../tests/fixtures/spread/object_basic.subm | 0 .../tests/fixtures/spread/object_multiple_spreads.subm | 0 .../fixtures/spread/object_override_literal_after.subm | 0 .../fixtures/spread/object_override_literal_before.subm | 0 .../tests/fixtures/spread_index_signature_union.ts | 0 .../tests/fixtures/spread_into_discriminated_union.ts | 0 .../tests/fixtures/spread_of_conditional_or_union.ts | 0 .../tests/fixtures/spread_of_falsy_value.ts | 0 .../tests/fixtures/spread_union_assigned_back.ts | 0 .../tests/fixtures/static_binding_as_value.ts | 0 .../fixtures/strict_mode_reserved_words_as_properties.ts | 0 .../tests/fixtures/string_admitted_builders.ts | 0 .../tests/fixtures/string_at_nullable.ts | 0 .../tests/fixtures/string_case.subm | 0 .../tests/fixtures/string_char_at.subm | 0 .../tests/fixtures/string_code_point_at_out_of_range.ts | 0 .../tests/fixtures/string_concat.subm | 0 .../tests/fixtures/string_for_of.subm | 0 .../tests/fixtures/string_from_char_code.subm | 0 .../tests/fixtures/string_from_char_code_wraps.ts | 0 .../tests/fixtures/string_from_code_point.subm | 0 .../tests/fixtures/string_index_of.subm | 0 .../tests/fixtures/string_key_member_access.ts | 0 .../tests/fixtures/string_length.subm | 0 .../tests/fixtures/string_linear_search.ts | 0 .../tests/fixtures/string_literal_lone_surrogates.ts | 0 .../tests/fixtures/string_match_all.subm | 0 .../tests/fixtures/string_match_and_search.subm | 0 .../tests/fixtures/string_multiline_raw_newline.ts | 0 .../tests/fixtures/string_normalize.subm | 0 .../tests/fixtures/string_of_null.ts | 0 .../tests/fixtures/string_ops_keep_lone_surrogates.ts | 0 .../tests/fixtures/string_or_array_union_methods.ts | 0 .../tests/fixtures/string_ordering.subm | 0 .../tests/fixtures/string_pad.subm | 0 .../tests/fixtures/string_repeat.subm | 0 .../tests/fixtures/string_repeat_negative.subm | 0 .../tests/fixtures/string_replace.subm | 0 .../tests/fixtures/string_replace_all.subm | 0 .../tests/fixtures/string_slice.subm | 0 .../tests/fixtures/string_split.subm | 0 .../tests/fixtures/string_starts_with.subm | 0 .../tests/fixtures/string_trim.subm | 0 .../tests/fixtures/string_well_formed.subm | 0 .../fixtures/structural_equals_cross_package/app/main.ts | 0 .../structural_equals_cross_package/packages.manifest | 0 .../structural_equals_cross_package/points/lib.ts | 0 .../tests/fixtures/structural_equals_shape_guard.ts | 0 .../tests/fixtures/structural_interfaces.subm | 0 .../tests/fixtures/structural_visit_budget.ts | 0 .../tests/fixtures/subclass_super_on_every_path.ts | 0 .../errors/expect_error_arrow_switch_fallthrough.ts | 0 .../expect_error_switch_assertNever_missing_variant.subm | 0 .../errors/expect_error_switch_case_type_mismatch.subm | 0 .../errors/expect_error_switch_continue_not_in_loop.subm | 0 .../switch/errors/expect_error_switch_duplicate_case.subm | 0 .../errors/expect_error_switch_duplicate_default.subm | 0 .../errors/expect_error_switch_enum_non_exhaustive.subm | 0 .../switch/errors/expect_error_switch_fallthrough.subm | 0 .../expect_error_switch_literal_union_non_exhaustive.subm | 0 .../expect_error_switch_multi_label_variant_field.subm | 0 .../errors/expect_error_switch_non_exhaustive_union.subm | 0 .../expect_error_switch_tuple_union_non_exhaustive.subm | 0 .../fixtures/switch/switch_assertNever_exhaustive.subm | 0 .../tests/fixtures/switch/switch_break_in_case.subm | 0 .../tests/fixtures/switch/switch_break_post_state.subm | 0 .../tests/fixtures/switch/switch_default_first.subm | 0 .../switch/switch_discriminated_union_narrowing.subm | 0 .../tests/fixtures/switch/switch_enum_discriminant.subm | 0 .../switch/switch_enum_exhaustive_no_default.subm | 0 .../fixtures/switch/switch_enum_exhaustive_string.subm | 0 .../switch/switch_inside_loop_break_targets_switch.subm | 0 .../switch/switch_inside_loop_continue_targets_loop.subm | 0 .../switch/switch_literal_union_default_narrows.subm | 0 .../fixtures/switch/switch_literal_union_exhaustive.subm | 0 .../tests/fixtures/switch/switch_multi_label.subm | 0 .../fixtures/switch/switch_multi_label_discriminated.subm | 0 .../fixtures/switch/switch_multi_label_literal_union.subm | 0 .../tests/fixtures/switch/switch_no_default.subm | 0 .../tests/fixtures/switch/switch_number_basic.subm | 0 .../tests/fixtures/switch/switch_return_in_case.subm | 0 .../tests/fixtures/switch/switch_string_basic.subm | 0 .../fixtures/switch/switch_tuple_union_exhaustive.subm | 0 .../fixtures/switch_case_body_recovery_no_panic.subm | 0 .../tests/fixtures/switch_case_hex_literal.subm | 0 .../switch_case_null_absent_field_stays_reachable.ts | 0 .../tests/fixtures/switch_expression_label_duplicates.ts | 0 .../tests/fixtures/switch_expression_labels.ts | 0 .../fixtures/switch_function_declarations_hoisted.ts | 0 .../tests/fixtures/switch_null_assignment_in_loop.ts | 0 .../tests/fixtures/switch_nullable.ts | 0 .../tests/fixtures/switch_signed_number_labels.ts | 0 .../tests/fixtures/syntax_nesting_near_limit.ts | 0 .../tests/fixtures/template_generic_null.ts | 0 .../tests/fixtures/template_literal_boolean.subm | 0 .../tests/fixtures/template_literal_interface.ts | 0 .../tests/fixtures/template_literal_nested.subm | 0 .../tests/fixtures/template_literal_no_substitution.subm | 0 .../tests/fixtures/template_literal_non_null_assert.ts | 0 .../tests/fixtures/template_literal_nullish.ts | 0 .../tests/fixtures/template_literal_number.subm | 0 .../tests/fixtures/template_literal_string.subm | 0 .../tests/fixtures/template_literal_tuple.ts | 0 .../tests/fixtures/template_nesting_near_limit.ts | 0 .../tests/fixtures/template_substitution_spans.ts | 0 .../fixtures/temporal/fields_bag_by_interface_type.ts | 0 .../tests/fixtures/temporal_compare.subm | 0 .../tests/fixtures/temporal_compare_sort.subm | 0 .../tests/fixtures/temporal_duration_arithmetic.subm | 0 .../tests/fixtures/temporal_duration_compare_from.subm | 0 .../tests/fixtures/temporal_duration_from_iso.subm | 0 .../tests/fixtures/temporal_duration_host_validation.ts | 0 .../tests/fixtures/temporal_duration_like_arg.subm | 0 .../tests/fixtures/temporal_duration_object_literal.subm | 0 .../tests/fixtures/temporal_duration_round_total.subm | 0 .../tests/fixtures/temporal_duration_sign.subm | 0 .../fixtures/temporal_duration_to_string_options.subm | 0 .../tests/fixtures/temporal_duration_with_abs_blank.subm | 0 .../tests/fixtures/temporal_duration_zdt_anchor.subm | 0 .../tests/fixtures/temporal_error_messages.subm | 0 .../tests/fixtures/temporal_errors_are_catchable.subm | 0 .../tests/fixtures/temporal_getters.subm | 0 .../tests/fixtures/temporal_hook_contract.ts | 0 .../tests/fixtures/temporal_instant_arithmetic.subm | 0 .../fixtures/temporal_instant_epoch_nanos_bigint.subm | 0 .../tests/fixtures/temporal_instant_equals.subm | 0 .../tests/fixtures/temporal_instant_from_epoch.subm | 0 .../tests/fixtures/temporal_instant_iso_round_trip.subm | 0 .../tests/fixtures/temporal_instant_round.subm | 0 .../tests/fixtures/temporal_long_duration.subm | 0 .../tests/fixtures/temporal_negative_duration.subm | 0 .../tests/fixtures/temporal_now_plain.subm | 0 .../tests/fixtures/temporal_now_smoke.subm | 0 .../tests/fixtures/temporal_now_time_zone_id.subm | 0 .../tests/fixtures/temporal_now_zoned_date_time_iso.subm | 0 .../tests/fixtures/temporal_numeric_range_validation.ts | 0 .../tests/fixtures/temporal_options_interface_arg.ts | 0 .../tests/fixtures/temporal_plain_arithmetic.subm | 0 .../tests/fixtures/temporal_plain_erased_boundaries.ts | 0 .../fixtures/temporal_plain_to_yearmonth_monthday.subm | 0 .../tests/fixtures/temporal_plain_to_zoned.subm | 0 .../tests/fixtures/temporal_plaindate.subm | 0 .../fixtures/temporal_plaindate_to_plaindatetime.subm | 0 .../tests/fixtures/temporal_plaindatetime.subm | 0 .../tests/fixtures/temporal_plainmonthday.subm | 0 .../tests/fixtures/temporal_plaintime.subm | 0 .../tests/fixtures/temporal_plainyearmonth.subm | 0 .../tests/fixtures/temporal_to_json.subm | 0 .../tests/fixtures/temporal_until_options.subm | 0 .../tests/fixtures/temporal_with.subm | 0 .../temporal_yearmonth_monthday_to_plaindate.subm | 0 .../tests/fixtures/temporal_zdt_alias_identity.ts | 0 .../tests/fixtures/temporal_zdt_dst_spring_forward.subm | 0 .../tests/fixtures/temporal_zdt_equals.subm | 0 .../tests/fixtures/temporal_zdt_from_iso.subm | 0 .../tests/fixtures/temporal_zdt_host_complete.ts | 0 .../fixtures/temporal_zdt_missing_member_diagnostic.subm | 0 .../tests/fixtures/temporal_zdt_to_instant.subm | 0 .../tests/fixtures/temporal_zdt_to_plain.subm | 0 .../tests/fixtures/temporal_zdt_with_time_zone.subm | 0 .../tests/fixtures/temporal_zoned_round_trip.subm | 0 .../fixtures/ternary/expect_error_missing_colon.subm | 0 .../tests/fixtures/ternary/logical_branches.ts | 0 .../tests/fixtures/ternary/narrowing.subm | 0 .../tests/fixtures/ternary/nested.subm | 0 .../tests/fixtures/ternary/simple.subm | 0 .../tests/fixtures/ternary/truthiness_cond.subm | 0 .../tests/fixtures/ternary/void_branches.ts | 0 .../tests/fixtures/ternary/with_optional_chain.subm | 0 .../tests/fixtures/text_codec_unicode.subm | 0 .../tests/fixtures/text_codec_with_base64.subm | 0 .../tests/fixtures/text_encoder_round_trip.subm | 0 .../tests/fixtures/to_json_record_non_string_throws.ts | 0 .../tests/fixtures/top_level_function_identity.ts | 0 .../tests/fixtures/tostring_default_still_works.subm | 0 .../tests/fixtures/tostring_field_override.subm | 0 .../fixtures/tostring_field_override_with_capture.subm | 0 .../tests/fixtures/trailing_commas.subm | 0 .../tests/fixtures/truthiness/always_truthy.ts | 0 .../tests/fixtures/truthiness/and_value.ts | 0 .../tests/fixtures/truthiness/bigint_cond.ts | 0 .../tests/fixtures/truthiness/boolean_or_null.ts | 0 .../tests/fixtures/truthiness/false_branch_keeps_type.ts | 0 .../tests/fixtures/truthiness/logical_in_condition.ts | 0 .../tests/fixtures/truthiness/number_cond.ts | 0 .../tests/fixtures/truthiness/or_default.ts | 0 .../tests/fixtures/truthiness/string_cond.ts | 0 .../tests/fixtures/truthiness/string_or_null_empty.ts | 0 .../tests/fixtures/truthiness_rules_out_to_never.ts | 0 .../tests/fixtures/ts_single.ts | 0 .../tests/fixtures/tuple_as_array.subm | 0 .../tests/fixtures/tuple_as_iterable_source.ts | 0 .../tests/fixtures/tuple_basic.subm | 0 .../tests/fixtures/tuple_in_array.subm | 0 .../tests/fixtures/tuple_json_stringify.subm | 0 .../tests/fixtures/tuple_labels.ts | 0 .../tests/fixtures/tuple_length.subm | 0 .../tests/fixtures/tuple_methods.subm | 0 .../tests/fixtures/tuple_nested.subm | 0 .../tests/fixtures/tuple_union_index_access.subm | 0 .../tuples/expect_error_optional_to_required_undefined.ts | 0 .../tests/fixtures/tuples/issue_988_arity.ts | 0 .../tests/fixtures/tuples/issue_988_correlation.ts | 0 .../tests/fixtures/tuples/issue_988_union_context.ts | 0 .../tests/fixtures/tuples/optional_elements.ts | 0 .../fixtures/tuples/required_undefined_to_optional.ts | 0 .../tests/fixtures/type-aliases/alias_null_in_union.subm | 0 .../fixtures/type-aliases/alias_string_host_call.subm | 0 .../fixtures/type-aliases/alias_tuple_literal_return.ts | 0 .../tests/fixtures/type-aliases/alias_union_dedup.ts | 0 .../type-aliases/aliased_function_type_const.subm | 0 .../tests/fixtures/type-aliases/aliased_void_return.ts | 0 .../tests/fixtures/type-aliases/aliased_void_value.ts | 0 .../expect_error_generic_alias_arity_missing.subm | 0 .../expect_error_generic_alias_arity_too_many.subm | 0 .../type-aliases/expect_error_type_alias_duplicate.subm | 0 .../expect_error_type_alias_generic_args.subm | 0 .../type-aliases/expect_error_type_alias_mismatch.subm | 0 .../expect_error_type_alias_unknown_body.subm | 0 .../expect_warning_non_nullable_recursive_alias.ts | 0 .../tests/fixtures/type-aliases/generic_alias_box.subm | 0 .../type-aliases/generic_alias_in_function_signature.subm | 0 .../tests/fixtures/type-aliases/generic_alias_nested.subm | 0 .../tests/fixtures/type-aliases/generic_alias_pair.subm | 0 .../mutually_recursive_alias_cross_package/app/main.ts | 0 .../mutually_recursive_alias_cross_package/lib/lib.ts | 0 .../packages.manifest | 0 .../type-aliases/mutually_recursive_alias_nullability.ts | 0 .../fixtures/type-aliases/non_generic_alias_nested.subm | 0 .../tests/fixtures/type-aliases/type_alias_array.subm | 0 .../type-aliases/type_alias_discriminated_union.subm | 0 .../tests/fixtures/type-aliases/type_alias_object.subm | 0 .../tests/fixtures/type-aliases/type_alias_primitive.subm | 0 .../tests/fixtures/type-aliases/type_alias_union.subm | 0 .../tests/fixtures/type_guard_rendering_names_the_loss.ts | 0 .../tests/fixtures/type_member_line_breaks.ts | 0 .../tests/fixtures/type_members_named_like_keywords.ts | 0 .../tests/fixtures/type_size_near_limit.ts | 0 .../tests/fixtures/typeof_alone.subm | 0 .../tests/fixtures/typeof_enum_member.ts | 0 .../tests/fixtures/typeof_function_narrows_union.ts | 0 .../tests/fixtures/typeof_type_query.ts | 0 .../tests/fixtures/typeof_undefined_type_query.ts | 0 .../fixtures/types/expect_error_any_not_supported.ts | 0 .../types/expect_error_bare_function_type_params.ts | 0 .../types/expect_error_function_type_param_typo.ts | 0 .../fixtures/types/expect_error_unclosed_grouped_type.ts | 0 .../tests/fixtures/types/parenthesized_type.ts | 0 .../tests/fixtures/uint8array_alloc.subm | 0 .../tests/fixtures/uint8array_at.subm | 0 .../tests/fixtures/uint8array_base64.subm | 0 .../tests/fixtures/uint8array_base64_options.subm | 0 .../tests/fixtures/uint8array_byte_length.subm | 0 .../tests/fixtures/uint8array_copy_within.subm | 0 .../tests/fixtures/uint8array_equals.subm | 0 .../tests/fixtures/uint8array_fill.subm | 0 .../tests/fixtures/uint8array_filter.subm | 0 .../tests/fixtures/uint8array_find.subm | 0 .../tests/fixtures/uint8array_for_each.subm | 0 .../tests/fixtures/uint8array_from_array.subm | 0 .../tests/fixtures/uint8array_from_bytes.subm | 0 .../tests/fixtures/uint8array_from_hex_errors.subm | 0 .../tests/fixtures/uint8array_hex.subm | 0 .../tests/fixtures/uint8array_host_vtable.ts | 0 .../tests/fixtures/uint8array_index_bounds.ts | 0 .../tests/fixtures/uint8array_index_of.subm | 0 .../tests/fixtures/uint8array_indexed_write.subm | 0 .../tests/fixtures/uint8array_join.subm | 0 .../tests/fixtures/uint8array_map.subm | 0 .../tests/fixtures/uint8array_new.subm | 0 .../tests/fixtures/uint8array_new_length.ts | 0 .../tests/fixtures/uint8array_of.subm | 0 .../tests/fixtures/uint8array_ranged_mutations.ts | 0 .../tests/fixtures/uint8array_reduce.subm | 0 .../tests/fixtures/uint8array_reverse.subm | 0 .../tests/fixtures/uint8array_set.subm | 0 .../tests/fixtures/uint8array_set_out_of_range.subm | 0 .../tests/fixtures/uint8array_slice.subm | 0 .../tests/fixtures/uint8array_some_every.subm | 0 .../tests/fixtures/uint8array_sort.subm | 0 .../tests/fixtures/uint8array_subarray.subm | 0 .../tests/fixtures/uint8array_to_json.subm | 0 .../tests/fixtures/uint8array_to_reversed.subm | 0 .../tests/fixtures/uint8array_to_sorted.subm | 0 .../tests/fixtures/uint8array_to_string.subm | 0 .../tests/fixtures/uint8array_truncate.subm | 0 .../tests/fixtures/uint8array_with.subm | 0 .../tests/fixtures/uint8array_wraps_like_to_uint8.ts | 0 .../tests/fixtures/unary_plus_string.ts | 0 .../tests/fixtures/undefined/defaults.ts | 0 .../tests/fixtures/undefined/expect_error_required.ts | 0 .../fixtures/undefined/expect_error_required_argument.ts | 0 .../tests/fixtures/undefined/methods.ts | 0 .../tests/fixtures/undefined/primitives.ts | 0 .../tests/fixtures/undefined/properties.ts | 0 .../tests/fixtures/undefined_array_literal_elements.ts | 0 .../fixtures/undefined_array_literal_nullish_lead.ts | 0 .../tests/fixtures/undefined_base_constructor_order.ts | 0 .../undefined_binding_keeps_synthetic_undefined.ts | 0 .../tests/fixtures/undefined_class_method_alias.ts | 0 .../tests/fixtures/undefined_class_to_json_alias.ts | 0 .../tests/fixtures/undefined_closure_returns.ts | 0 .../tests/fixtures/undefined_collections.ts | 0 .../fixtures/undefined_default_parameter_write_type.ts | 0 .../tests/fixtures/undefined_destructuring_defaults.ts | 0 .../fixtures/undefined_function_optional_compatibility.ts | 0 .../tests/fixtures/undefined_generic_union_inference.ts | 0 .../fixtures/undefined_inferred_parameter_defaults.ts | 0 .../tests/fixtures/undefined_json.ts | 0 .../undefined_later_destructured_parameter_capture.ts | 0 .../tests/fixtures/undefined_later_inferred_default.ts | 0 .../undefined_narrowing/default_parameter_truthiness.ts | 0 .../expect_error_chain_null_guard_keeps_missing.ts | 0 .../expect_error_effectful_undefined_guard.ts | 0 .../expect_error_null_guard_keeps_undefined.ts | 0 .../expect_error_optional_discriminant_unequal.ts | 0 .../expect_error_presence_keeps_undefined.ts | 0 .../expect_error_switch_optional_discriminant_missing.ts | 0 .../expect_error_switch_optional_field_missing.ts | 0 .../expect_error_undefined_guard_keeps_null.ts | 0 .../expect_error_void_member_is_not_narrowed_away.ts | 0 .../tests/fixtures/undefined_narrowing/guards.ts | 0 .../fixtures/undefined_narrowing/nullish_discriminants.ts | 0 .../tests/fixtures/undefined_narrowing/optional_chain.ts | 0 .../optional_discriminant_shared_undefined.ts | 0 .../undefined_narrowing/optional_discriminant_unequal.ts | 0 .../optional_literal_field_beside_tag.ts | 0 .../optional_literal_field_interfaces.ts | 0 .../fixtures/undefined_narrowing/singleton_comparisons.ts | 0 .../switch_null_case_leaves_undefined.ts | 0 .../tuple_discriminant_undefined_position.ts | 0 .../tests/fixtures/undefined_narrowing/typeof_void.ts | 0 .../tests/fixtures/undefined_native_optional_methods.ts | 0 .../tests/fixtures/undefined_optional_method_body.ts | 0 .../fixtures/undefined_optional_method_implements.ts | 0 .../fixtures/undefined_parameter_default_source_types.ts | 0 .../tests/fixtures/undefined_parameter_default_tdz.ts | 0 .../tests/fixtures/undefined_parameter_defaults.ts | 0 .../fixtures/undefined_parameter_destructuring_order.ts | 0 .../tests/fixtures/undefined_parameter_pattern_capture.ts | 0 .../fixtures/undefined_parameter_pattern_literal_types.ts | 0 .../tests/fixtures/undefined_parameter_pattern_write.ts | 0 .../undefined_parameter_property_declared_type.ts | 0 .../undefined_parameter_property_inferred_type.ts | 0 .../tests/fixtures/undefined_parameter_tdz.ts | 0 .../tests/fixtures/undefined_return_completion.ts | 0 .../tests/fixtures/undefined_runtime.ts | 0 .../tests/fixtures/undefined_strings.ts | 0 .../tests/fixtures/undefined_temporal.ts | 0 .../tests/fixtures/undefined_tuple_spread.ts | 0 .../tests/fixtures/undefined_tuple_union.ts | 0 .../tests/fixtures/unicode_whitespace_and_slash_escape.ts | 0 .../tests/fixtures/union_cross_type_eq.subm | 0 .../fixtures/union_field_write_named_fix_round_trip.ts | 0 .../tests/fixtures/union_field_write_names_the_fix.ts | 0 .../fixtures/union_field_write_names_the_narrowing.ts | 0 .../fixtures/union_field_write_non_union_receiver.ts | 0 .../fixtures/union_field_write_unnarrowable_receiver.ts | 0 .../tests/fixtures/union_literal_known_fields.ts | 0 .../tests/fixtures/union_member_lowering_nullability.ts | 0 .../tests/fixtures/union_primitive_eq.subm | 0 .../tests/fixtures/unknown/array_isarray.subm | 0 .../tests/fixtures/unknown/array_isarray_null.subm | 0 .../fixtures/unknown/array_isarray_null_runtime.subm | 0 .../tests/fixtures/unknown/closure_returns_null.subm | 0 .../unknown/contextual_closure_returns_unknown.ts | 0 .../tests/fixtures/unknown/eq_literal.ts | 0 .../tests/fixtures/unknown/eq_null.subm | 0 .../tests/fixtures/unknown/expect_error_and_or.subm | 0 .../tests/fixtures/unknown/expect_error_arithmetic.subm | 0 .../fixtures/unknown/expect_error_body_never_returns.ts | 0 .../tests/fixtures/unknown/expect_error_call.subm | 0 .../tests/fixtures/unknown/expect_error_field_access.subm | 0 .../tests/fixtures/unknown/expect_error_index_access.subm | 0 .../expect_error_non_null_assertion_stays_unknown.ts | 0 .../tests/fixtures/unknown/expect_error_ordering.subm | 0 .../tests/fixtures/unknown/expect_error_truthiness.subm | 0 .../tests/fixtures/unknown/generic_null_arg.subm | 0 .../fixtures/unknown/no_value_cross_package/app/main.ts | 0 .../fixtures/unknown/no_value_cross_package/lib/lib.ts | 0 .../unknown/no_value_cross_package/packages.manifest | 0 .../tests/fixtures/unknown/no_value_returns_null.ts | 0 .../tests/fixtures/unknown/null_into_unknown.subm | 0 .../tests/fixtures/unknown/parameter_round_trip.subm | 0 .../tests/fixtures/unknown/short_circuit.subm | 0 .../tests/fixtures/unknown/tostring.subm | 0 .../tests/fixtures/unknown/typeof_narrowing.subm | 0 .../tests/fixtures/unknown_array_null_element.ts | 0 .../tests/fixtures/uri_encode_decode.subm | 0 .../tests/fixtures/uri_error_builtin.ts | 0 .../tests/fixtures/url/build_basic.subm | 0 .../tests/fixtures/url/build_host_only.ts | 0 .../tests/fixtures/url/encode_decode_component.subm | 0 .../tests/fixtures/url/encode_decode_query.subm | 0 .../tests/fixtures/url/field_narrowing_guard.ts | 0 .../tests/fixtures/url/parse_basic.subm | 0 .../tests/fixtures/url/parse_empty_query.subm | 0 .../tests/fixtures/url/parse_host_trailing_dot.ts | 0 .../tests/fixtures/url/parse_invalid_type_error.ts | 0 .../tests/fixtures/url/parse_no_fragment.subm | 0 .../tests/fixtures/url/parse_no_port.subm | 0 .../tests/fixtures/url/parse_query_encoded.subm | 0 .../tests/fixtures/url/parse_query_multiple.subm | 0 .../tests/fixtures/url/query_type_alias.subm | 0 .../tests/fixtures/void_accessor_nested_value.ts | 0 .../tests/fixtures/void_array_element_generic_value.ts | 0 .../tests/fixtures/void_array_element_shorthand_value.ts | 0 .../tests/fixtures/void_as_generic_arg_value.ts | 0 .../tests/fixtures/void_behind_warning_value.ts | 0 .../tests/fixtures/void_class_field_value.ts | 0 .../tests/fixtures/void_class_static_field_value.ts | 0 .../tests/fixtures/void_closure_param_value.ts | 0 .../fixtures/void_conditional_cast_and_json_value.ts | 0 .../fixtures/void_conditional_in_comparisons_value.ts | 0 .../tests/fixtures/void_equality_value.ts | 0 .../tests/fixtures/void_function_param_value.ts | 0 .../fixtures/void_function_type_alias_param_value.ts | 0 .../tests/fixtures/void_function_type_param_value.ts | 0 .../tests/fixtures/void_hint_diverging_closure.ts | 0 .../tests/fixtures/void_inferred_type_argument.ts | 0 .../tests/fixtures/void_interface_method_type_argument.ts | 0 .../tests/fixtures/void_interface_property_value.ts | 0 .../tests/fixtures/void_interface_type_argument.ts | 0 .../tests/fixtures/void_into_value_slot_value.ts | 0 .../tests/fixtures/void_literal_element_value.ts | 0 .../void_nested_argument_does_not_hide_never_error.ts | 0 .../tests/fixtures/void_nullish_left_value.ts | 0 .../tests/fixtures/void_object_field_type_value.ts | 0 .../fixtures/void_recursive_interface_type_argument.ts | 0 .../fixtures/void_recursive_permutation_type_argument.ts | 0 .../tests/fixtures/void_return_position.ts | 0 .../tests/fixtures/void_return_type_argument.ts | 0 .../tests/fixtures/void_setter_param_value.ts | 0 .../tests/fixtures/void_switch_discriminant_value.ts | 0 .../tests/fixtures/void_tuple_element_value.ts | 0 .../tests/fixtures/void_union_condition.ts | 0 .../tests/fixtures/void_union_member_value.ts | 0 .../tests/fixtures/void_value_annotations.ts | 0 .../tests/fixtures/weak_type_shared_field.ts | 0 .../{submilli-engine => interpreter}/tests/git_memory.rs | 0 .../{submilli-engine => interpreter}/tests/host_memory.rs | 0 .../{submilli-engine => interpreter}/tests/http_live.rs | 0 .../tests/http_live_fixtures/download_basic.subm | 0 .../http_live_fixtures/download_gzip_decompress.subm | 0 .../tests/http_live_fixtures/get_200_body.subm | 0 .../tests/http_live_fixtures/get_404.subm | 0 .../tests/http_live_fixtures/headers_authorization.subm | 0 .../headers_missing_auth_returns_404.subm | 0 .../tests/http_live_fixtures/json_body.subm | 0 .../tests/http_live_fixtures/json_method.subm | 0 .../tests/http_live_fixtures/post_array_body.subm | 0 .../tests/http_live_fixtures/post_null_body.subm | 0 .../tests/http_live_fixtures/post_object_body.subm | 0 .../http_live_fixtures/post_object_body_custom_ct.subm | 0 .../tests/http_live_fixtures/post_string_body.subm | 0 .../tests/http_live_fixtures/post_uint8array_body.subm | 0 .../tests/http_live_fixtures/post_undefined_body.ts | 0 .../http_live_fixtures/put_string_body_ct_override.subm | 0 .../tests/http_live_fixtures/request_runtime_verb.subm | 0 .../tests/http_live_fixtures/response_to_string.subm | 0 .../tests/http_live_fixtures/verb_matrix.subm | 0 .../tests/http_tls_fixtures/ca.pem | 0 .../tests/http_tls_fixtures/localhost-key.pem | 0 .../tests/http_tls_fixtures/localhost.pem | 0 .../tests/lexer_limits.rs | 0 .../{submilli-engine => interpreter}/tests/memory_caps.rs | 0 .../tests/namespace_limits.rs | 0 .../tests/object_vtable_dispatch.rs | 0 .../tests/package_diagnostic_snapshots.rs | 0 .../tests/parser_depth.rs | 0 .../tests/record_limits.rs | 0 ...hots__b1_call_non_callable_lifts_number_interface.snap | 2 +- .../diagnostic_snapshots__b1_dynamic_object_index.snap | 2 +- ...iagnostic_snapshots__b1_field_not_found_on_object.snap | 2 +- .../diagnostic_snapshots__b1_index_into_non_array.snap | 2 +- ...hots__b2_call_arity_mismatch_lifts_anon_signature.snap | 2 +- ...ction_arg_unify_mismatch_lifts_signature_and_diff.snap | 2 +- ...eric_method_type_arg_arity_lifts_method_signature.snap | 2 +- ...tic_snapshots__b2_intrinsic_arity_lifts_signature.snap | 2 +- ...__b2_method_arity_mismatch_lifts_method_signature.snap | 2 +- ..._b2_number_coercion_type_mismatch_lifts_signature.snap | 2 +- ...snapshots__b3_unknown_type_suggests_close_builtin.snap | 2 +- ...lved_identifier_no_suggestion_when_no_close_match.snap | 2 +- ...ts__b3_unresolved_identifier_suggests_close_local.snap | 2 +- ...apshots__b4_cannot_infer_type_param_function_help.snap | 2 +- ...stic_snapshots__b4_const_missing_initializer_help.snap | 2 +- ...agnostic_snapshots__b4_const_reassign_global_help.snap | 2 +- ...iagnostic_snapshots__b4_const_reassign_local_help.snap | 2 +- .../diagnostic_snapshots__b4_function_reassign_help.snap | 2 +- ...nostic_snapshots__b4_let_missing_initializer_help.snap | 2 +- .../diagnostic_snapshots__b4_missing_main_help.snap | 2 +- ...diagnostic_snapshots__b4_missing_return_type_help.snap | 2 +- ...ostic_snapshots__b4_param_missing_annotation_help.snap | 2 +- ...nostic_snapshots__b4_return_outside_function_help.snap | 2 +- .../diagnostic_snapshots__b4_unknown_escape_help.snap | 2 +- ..._snapshots__b5_close_match_reported_at_each_field.snap | 2 +- ...pshots__b5_fresh_object_literal_excess_field_help.snap | 2 +- ...iagnostic_snapshots__b5_function_type_assign_diff.snap | 2 +- ...nostic_snapshots__b5_object_boundary_diff_in_call.snap | 2 +- ...shots__b5_object_field_assign_value_mismatch_diff.snap | 2 +- .../diagnostic_snapshots__doc_duplicate_param_warns.snap | 2 +- .../diagnostic_snapshots__doc_missing_returns_warns.snap | 2 +- ...agnostic_snapshots__doc_param_name_mismatch_warns.snap | 2 +- ...agnostic_snapshots__doc_property_with_param_warns.snap | 2 +- .../diagnostic_snapshots__doc_returns_on_void_warns.snap | 2 +- ...nostic_snapshots__doc_surfaces_in_call_arity_lift.snap | 2 +- .../diagnostic_snapshots__doc_unknown_tag_warns.snap | 2 +- .../diagnostic_snapshots__multi_catch_duplicate_arm.snap | 2 +- ...diagnostic_snapshots__multi_catch_unreachable_arm.snap | 2 +- ...agnostic_snapshots__null_tostring_offers_fix_trio.snap | 2 +- ...napshots__prelude_doc_surfaces_in_array_push_lift.snap | 2 +- ...snapshots__caller_value_passed_on_after_the_check.snap | 2 +- ...__check_in_a_function_the_package_does_not_export.snap | 2 +- ...ic_snapshots__property_read_again_after_the_check.snap | 2 +- .../tests/substitution_limits.rs | 0 .../tests/traps_in_callbacks.rs | 0 .../{submilli-engine => interpreter}/tests/type_limits.rs | 0 .../tests/vfs_containment.rs | 0 crates/submilli-build/Cargo.toml | 2 +- ...at_definition__tests__function_renders_arrow_form.snap | 5 ----- ...ition__tests__interface_renders_optional_property.snap | 7 ------- ...t_definition__tests__interface_renders_properties.snap | 8 -------- ...on__tests__interface_substitutes_property_generic.snap | 7 ------- ...efinition__tests__object_renders_structural_shape.snap | 8 -------- ...efinition__tests__primitive_with_declared_methods.snap | 7 ------- ...cker__infer__type_diff__tests__object_extra_field.snap | 5 ----- ...er__infer__type_diff__tests__object_missing_field.snap | 5 ----- crates/submilli-policy/Cargo.toml | 4 ++-- crates/submilli-server/Cargo.toml | 2 +- crates/submilli-shared/Cargo.toml | 2 +- crates/submilli/Cargo.toml | 2 +- examples/docker/conformance.ts | 2 +- 3177 files changed, 153 insertions(+), 153 deletions(-) rename crates/{submilli-engine => interpreter}/Cargo.toml (100%) rename crates/{submilli-engine => interpreter}/README.md (100%) rename crates/{submilli-engine => interpreter}/build.rs (100%) rename crates/{submilli-engine => interpreter}/src/arena.rs (100%) rename crates/{submilli-engine => interpreter}/src/artifact_f64.rs (100%) rename crates/{submilli-engine => interpreter}/src/asi.rs (100%) rename crates/{submilli-engine => interpreter}/src/ast.rs (100%) rename crates/{submilli-engine => interpreter}/src/authority.rs (100%) rename crates/{submilli-engine => interpreter}/src/backtrace.rs (100%) rename crates/{submilli-engine => interpreter}/src/capability_derivation.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/analysis.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/argument_defaults.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/bigint_pool.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/bounds.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/box_types.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/call_arguments.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/cast_check.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/cast_diagnostics.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/classes.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/closure_coercions.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/closures.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/dependency_usage.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/dwarf.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/field_guards.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/field_lookup.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/field_name_strings.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/field_names.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_adapters.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/binding_cells.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/cast.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/expr.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/finally.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/json.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/mcp.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/function_emitter/stmt.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/imported_classes.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/init_guard.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/intrinsics.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/invariant_tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/nullish.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/recursive_validators.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/runtime_descriptors.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/runtime_values.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/runtime_values/declarations.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/runtime_values/flow.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/runtime_values/rewrite.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap (78%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap (95%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap (89%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap (92%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap (93%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap (93%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap (94%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap (80%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap (88%) rename crates/{submilli-engine => interpreter}/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap (92%) rename crates/{submilli-engine => interpreter}/src/codegen/string_pool.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/symbol_table.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/this_binding.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/throw.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/user_subtypes.rs (100%) rename crates/{submilli-engine => interpreter}/src/codegen/vtable_walk.rs (100%) rename crates/{submilli-engine => interpreter}/src/compile.rs (100%) rename crates/{submilli-engine => interpreter}/src/compile_capabilities.rs (100%) rename crates/{submilli-engine => interpreter}/src/compiler_error.rs (100%) rename crates/{submilli-engine => interpreter}/src/compiler_limits.rs (100%) rename crates/{submilli-engine => interpreter}/src/diagnostics.rs (100%) rename crates/{submilli-engine => interpreter}/src/did_you_mean.rs (100%) rename crates/{submilli-engine => interpreter}/src/doc_comment.rs (100%) rename crates/{submilli-engine => interpreter}/src/lexer.rs (100%) rename crates/{submilli-engine => interpreter}/src/lib.rs (100%) rename crates/{submilli-engine => interpreter}/src/literal_units.rs (100%) rename crates/{submilli-engine => interpreter}/src/lower_patterns.rs (100%) rename crates/{submilli-engine => interpreter}/src/mangle.rs (100%) rename crates/{submilli-engine => interpreter}/src/package_declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/packages.rs (100%) rename crates/{submilli-engine => interpreter}/src/parser.rs (100%) rename crates/{submilli-engine => interpreter}/src/rendering.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/agents.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/array_storage.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/blocking.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/call_log.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/decision.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/disk_quota.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/embedding.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/exec.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/fs.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/fs/removal.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/fuel.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/gc_singleton.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/host.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/intrinsic_types.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/json.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/json/format.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/json_text.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/limits.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/llm.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/mcp.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/mcp/response.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/metrics.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/number.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/arguments.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/array/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/array/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/array/sort.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/bigint/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/bigint/ops.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/bitwise.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/boolean/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/closure.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/collection.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/console.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/error.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/iterator/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/keep.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/ledger.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/map/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/map/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/math.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/member.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/number/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/object/dynamic.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/object/index.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/object/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/object/static_value.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/regex/engine.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/regex/input.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/regex/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/regex/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/regex/output.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/set/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/set/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/string/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/string/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/string/search.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/string/transforms.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/duration/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/duration/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/instant/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/instant/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/now/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/now/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_date/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_date/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_date_time/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_date_time/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_month_day/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_month_day/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_time/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_time/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_year_month/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/plain_year_month/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/shared.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/zoned_date_time/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/zoned_date_time/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/textcodec/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/textcodec/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/uint8array/install.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/uint8array/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/undefined.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/uri.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/value.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/vtable.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/prelude/vtable/serialization.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/secrets.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/security.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/session_kv.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/skills.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/token_ledger.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/vfs.rs (100%) rename crates/{submilli-engine => interpreter}/src/runtime/watchdog.rs (100%) rename crates/{submilli-engine => interpreter}/src/shape.rs (100%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap (95%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap (73%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap (73%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap (87%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap (81%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap (77%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap (82%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap (77%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap (82%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap (82%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap (73%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap (69%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap (74%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap (74%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap (96%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap (98%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap (99%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap (88%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap (98%) rename crates/{submilli-engine => interpreter}/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap (99%) rename crates/{submilli-engine => interpreter}/src/source.rs (100%) rename crates/{submilli-engine => interpreter}/src/source_validation.rs (100%) rename crates/{submilli-engine => interpreter}/src/span.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/abi.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/agents/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/agents/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/capabilities.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/budget.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/myers.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/patch.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/text.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/code/walk.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/crypto.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/dot_segments.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/embedding/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/embedding/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/fs/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/fs/handles.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/fs/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/class.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/diff.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/history.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/index_limits.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/integration_tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/location.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/lock.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/log_cache.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/metadata_scan.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/meter.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/object.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/operations.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/pack_index_check.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/pack_limits.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/stage.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/storage.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/transport.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/work.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/git/worker.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/policy.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/redirect_guard.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/transport.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/transport_policy.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/transport_policy_tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/http/transport_tls_tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/llm/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/llm/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/optional_tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/secrets.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/security.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/session/cursor.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/session/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/session/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/session/value.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/shared.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/skills/declaration.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/skills/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/test.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/url.rs (100%) rename crates/{submilli-engine => interpreter}/src/stdlib/uuid.rs (100%) rename crates/{submilli-engine => interpreter}/src/token.rs (100%) rename crates/{submilli-engine => interpreter}/src/tree_height.rs (100%) rename crates/{submilli-engine => interpreter}/src/type_info.rs (100%) rename crates/{submilli-engine => interpreter}/src/type_rendering.rs (100%) rename crates/{submilli-engine => interpreter}/src/type_size.rs (100%) rename crates/{submilli-engine => interpreter}/src/type_walk.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/capture.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/desugar/do_while.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/desugar/for_loop.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/desugar/for_of.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/desugar/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/desugar/postfix_incdec.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/aliased_conditions.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/assign_expr.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/assignable.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/best_common_type.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/binding_analysis.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/classes.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/closure_arity.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/comparable.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/comparison_operand.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/diagnostics.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/enums.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/exports.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/expr.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/format_definition.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/format_signature.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/forward_globals.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/generic.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/generic_scopes.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/globals.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/iife.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/import_graph.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/imports.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/inference_sources.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/literal_freshness.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/lookup.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/module_symbols.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/namespace_symbol.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/narrow_scopes.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/narrowing.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/nested_functions.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/object_normalization.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/param_defaults.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/predicate_envs.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/records.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/reserved.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/resolve_type.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/scopes.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/shapes.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/signatures.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap (99%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap (60%) create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap (53%) create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap (53%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap (70%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap (52%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap (52%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap (67%) create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap rename crates/{submilli-engine => interpreter}/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap (59%) create mode 100644 crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap rename crates/{submilli-engine => interpreter}/src/typechecker/infer/stmt.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/switch_stmt.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/test_support.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/type_aliases.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/type_diff.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/type_namespace.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/type_predicate.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/type_registry.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/value_operand.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/infer/variance.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/json_schema.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/json_strategy.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/body_walk.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/capability_consistency.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_calls.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/bodies.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/checked.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/findings.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/flow.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/origin.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/package.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/scope.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/stability.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/check_discipline/tests.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/control_flow.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/declarations.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/definite_assignment.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/doc_consistency.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/exported_docs.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/exported_signature_types.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/fallthrough.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/main_required.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/missing_return.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/mod.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/return_outside_function.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/super_call.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/rules/unreachable.rs (100%) rename crates/{submilli-engine => interpreter}/src/typechecker/type_param_substitution.rs (100%) rename crates/{submilli-engine => interpreter}/src/typed_ast.rs (100%) rename crates/{submilli-engine => interpreter}/src/types.rs (100%) rename crates/{submilli-engine => interpreter}/tests/checked_arena.rs (100%) rename crates/{submilli-engine => interpreter}/tests/checked_rendering.rs (100%) rename crates/{submilli-engine => interpreter}/tests/checked_source.rs (100%) rename crates/{submilli-engine => interpreter}/tests/checked_typed_phases.rs (100%) rename crates/{submilli-engine => interpreter}/tests/checked_untyped_phases.rs (100%) rename crates/{submilli-engine => interpreter}/tests/class_rec_group.rs (100%) rename crates/{submilli-engine => interpreter}/tests/closure_arity.rs (100%) rename crates/{submilli-engine => interpreter}/tests/closure_arity_diagnostics.rs (100%) rename crates/{submilli-engine => interpreter}/tests/closure_lowering_errors.rs (100%) rename crates/{submilli-engine => interpreter}/tests/compiler_structure_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/console_failure.rs (100%) rename crates/{submilli-engine => interpreter}/tests/cross_module_gc_types.rs (100%) rename crates/{submilli-engine => interpreter}/tests/decision_records.rs (100%) rename crates/{submilli-engine => interpreter}/tests/determinism.rs (100%) rename crates/{submilli-engine => interpreter}/tests/diagnostic_snapshots.rs (100%) rename crates/{submilli-engine => interpreter}/tests/field_lookup_size.rs (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures.rs (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/alias_index_read_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/alias_peel_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/angle_bracket_cast.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_at.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_callback_truthiness.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_concat.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_copy_within.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_every.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_fill.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_filter.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_filter_guard_narrows_to_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_filter_type_guard_narrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_find.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_findindex.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_flat.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_flat_depth_budget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_flat_depth_error.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_flatmap.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_for_each.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_from.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_from_array_like_length.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_from_array_like_wider_source.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_from_collections.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_generic_spelling.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_host_port_edges.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_includes.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_index_domain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_index_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_index_oob_throws.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_indexed_write_rhs_grows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_iter_next_result.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_join.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_join_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_keeps_regular_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_keys_values_entries.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_last_index_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_length.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_like_union_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_like_union_writes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_best_common_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_element_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_normalized_to_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_object_normalization.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_object_normalization_fresh_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_union_of_arrays.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_union_of_arrays_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_wider_element.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_literal_wider_element_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_map.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_of_object_literal_arrays_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_pop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_push.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_reduce.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_reduce_right.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_reverse.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_shift_unshift.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_slice.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_some.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_sort.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_sort_cached_units.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_sort_keeps_comparator_pushes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_sort_stable_merge.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_splice.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_spread_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_to_reversed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_to_sorted.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_to_spliced.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_values_host_iter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/array_with.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/arrow_return_type_forms.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_allman_braces.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_clause_and_arrow_wraps.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_keyword_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_line_break_after_as_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_line_wrapped_operators.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_statement_ends_at_closing_brace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_template_substitution_wraps.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/asi_type_members_in_brackets.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/assert_pass.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/assert_throws_catchable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/assignment_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/assignment_keeps_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/assignment_narrows_to_declared_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bare_return_in_inferred_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_arithmetic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_compare.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_container_equality.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_conversions.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_decimal_budget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_float_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_join.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_large_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_literal_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_literal_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_namespace_typo.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_number_exact.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_plus_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_to_json.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bigint_to_string_radix.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bind_void_call_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/calls.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/capture_block_shadow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/captured_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/early_assignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/early_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/for_of_pattern_shadow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/for_of_pattern_tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/for_of_tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/hygiene.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/hygiene_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/hygiene_iterator.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/intrinsic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/mutators.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/parseint_required_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/pattern_hygiene.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare_catch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare_let.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare_param.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare_pattern.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/redeclare_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/self_initialization.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/shadowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/binding_scope/tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/asi.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/assignments.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/bigints.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/coercion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/evaluation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/generics.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/invalid.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/invalid_unary.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/live_values.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bitwise/numbers.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/boolean_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/boxed_primitive_vtables.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/braceless_bodies_accepted.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/braceless_control_bodies.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/builtin_error.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/bulk_string_and_byte_copies.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/call_sig_number_from_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/call_sig_string_coercion.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/call_sig_user_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/captured_let_same_frame_reassign.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cast_and_spread_object_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cast_rest_function_to_fixed_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cast_self_nominal_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cast_to_union_member_overlap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cast_void_adapter_to_value_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_array_element_check.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_chain_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_enum_target.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_interface_non_object_throws.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_nested_and_optional.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_number_passthrough.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_object_literal_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_proven_upcast_no_check.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_recursive_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_recursive_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_string_passthrough.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_union_to_member.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_unknown_to_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/as_unknown_to_object_shape.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/expect_error_incompatible_static_cast.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/issue_905_paths.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/issue_982_disjoint.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/issue_982_literal_overlap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/uint8array_is_as.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/chain_generic_method_reference.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/chain_non_generic_optional_calls.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_destructure/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_destructured_param/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_for_of/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_package_value/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_primitives/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_response_mapping/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/clean_unguarded/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_argument/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_array_literal/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_callback/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_captured/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_context/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_merged/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_method_call/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_mutation/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_operand/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_returned/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_spread/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_stored/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/escape_thrown/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_closure/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_internal_module/internal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_internal_module/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_members/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_module_level/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_private_helper/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_reexport/internal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_reexport/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_iteration/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_alias/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_control/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_loop/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/class_chain_at_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/class_never_field_collection_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/class_to_string_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/class_used_before_declaration_throws.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/abstract_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_cross_package/geo/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_different_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_half_inherited.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_implements_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_override.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_redeclared_compatibly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_via_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/accessor_write_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/bad_override.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/captured_class_binding_boxed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/cast_accessor_conformance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/catch_generic_error_bare.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/closure_captures_this.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/closure_in_member_bodies.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/compound_assign_generic_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/construct_and_read_fields.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_default_and_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/dynamic_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_cross_package/labeled/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_cross_package/points/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_nullable_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_sibling_same_shape.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_structural_fields.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_subclass_vs_base.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/equals_vs_other_runtime_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_catch_closure_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_field_mutation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_throw_catch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_typed_catch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_subclass_typed_catch_finally.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/error_union_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_accessor_half_guards.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_missing_static.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_static_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_static_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_assign_to_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_bare_class_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_catch_generic_args.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_catch_non_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_catch_unrelated_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_compound_assign_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_field_redeclared_wider.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_field_used_before_initialization.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_implements_aliased_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_implements_missing_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_implements_wrong_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_implements_wrong_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_instance_on_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_instanceof_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_instanceof_unrelated.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_member_closures_and_switches.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_member_missing_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_member_unreachable_code.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_optional_vs_required_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_override_fewer_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_postfix_static_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_postfix_static_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_read_write_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_class_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_constructor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_field_no_init.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_instance_name_collision.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_on_instance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_on_instance_help.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_optional_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_this.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_subclass_shape_dump.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_to_string_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_type_beats_mutability.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_uninitialized_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/expect_error_unknown_static.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_module/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_module/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_module/zoo/animal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_module/zoo/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package/animals/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package/dogs/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package_private/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cross_package_private/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_cycle.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/extends_non_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_init_inherited.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_initializers.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_all_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_constructor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_enums.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_erased_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_generic_box.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_generic_context.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_host_info.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_narrowing_guard_union_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_in_subclass.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_without_initializer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_aliased_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_empty_subclass.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_generic_base.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_partial_override.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implements_via_later_declared_parent.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/implicit_ctor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_module/animals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_module/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_error_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_negative.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_sibling_same_shape.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_host_built.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_uint8array_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/instanceof_unknown_lhs.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927_argument_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927_cycle.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927_fixed_cycle.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_927_union_cycle.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_967_checked_return_abi.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_967_default_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_967_required.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_967_structural_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_967_wrong_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_973_shorthand_boundary.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_987_inline_object.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_987_private.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_987_setter_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/issue_987_weak_target.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/json_inherited_private/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/json_inherited_private/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/json_inherited_private/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/json_public_properties.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/map_set_class_keys.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/method_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/method_rewritten_through_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/multi_catch_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/multi_catch_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/object_literal_in_member_bodies.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/overridden_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/param_properties.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/permission_denied_error_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/postfix_field_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/private_constructor_packages/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/private_constructor_packages/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/private_cross_module/animal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/private_cross_module/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/protected_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/quota_exceeded_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/range_error_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/range_error_host_throws.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/readonly_write_outside_ctor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/setter_assignment_as_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_and_instance_same_name.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_classref_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_cross_package/mathx/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_generic_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_inheritance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_instance_name_collision.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_members_do_not_redeclare.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_method_as_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_method_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_assign.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_inherited_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_postfix.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_mutable_private.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_private.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_readonly_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/super_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/super_ctor_field_init.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/super_method_override.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/syntax_error_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/this_in_field_initializer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/this_outside_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/type_error_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/type_error_host_thrown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/typed_catch_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/typed_catch_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/undefined_reference_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/universal_to_json.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/universal_to_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_captures_class_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_coercion_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_coercion_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_coercion_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_counter.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_nullable_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_reads_later_module_variable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_accessor_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_after_substitution.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_from_class_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_from_local_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_from_uncalled_signatures.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_sig_shape_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_that_only_throws_is_never.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closure_variable_passed_to_hof.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/callbacks_declare_fewer_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/function_arity_edges.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/function_this.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/iife.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/named_function_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/nested_function_contexts.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/closures/nested_function_declarations.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/code/linear_diff.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/code/workspace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_iterators_live.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_keys_same_value_zero.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/array_from_mapping.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/array_from_nullable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/array_postfix_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/expect_error_spread_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/expect_error_spread_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/expect_error_spread_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/optional_index.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/optional_index_bounds.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/spread_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/tuple_boxing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/tuple_spread.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/uint8_postfix.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_regressions/uint8_postfix_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/collection_to_string_tag.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/comparable_methods_and_self_references.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_basic_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_bigint.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_const_error.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_for_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_index.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_pow_precedence.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_type_error_mixed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/compound_type_error_string_sub.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assign/receiver_evaluated_once.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_assignment_through_never_getter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/compound_write_widens_literal_target.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conditional_object_literal_normalization.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_bigint.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_boolean.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_map_set.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_math.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_regexp.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_temporal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conformance_uint8array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/console_log_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/console_log_variadic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/const_keeps_literals_through_operators.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/const_literal_survives_through_ternaries.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/const_literal_survives_where_immutable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/const_literal_widens_where_mutable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/constant_expression_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/constant_key_reads_as_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/all_five_as_names.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/from_binding_template.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/type_only_import_inline.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/contextual-keywords/type_only_import_statement.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/conversion_field_rest_and_this.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/crypto/hmac_sha256.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/crypto/random_bytes.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/crypto/sha256.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/crypto/sha512.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/crypto/timing_safe_equal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/cyclic_graph_host_walk.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/date_lowercase_variable_works.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/decode_uri_lone_surrogates.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_arrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_before_required.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_boxed_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_enum_variant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_global_const.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/default_param_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/array_hole.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/array_literal_as_tuple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/array_positional.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/array_rest.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/arrow_param_expr_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/class_member_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_array_literal_arity.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_for_of_arity.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/expect_error_rest_not_last.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/for_initializer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/for_of_map.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/for_of_tuple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/function_param.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/let_pattern_mutation.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/nested_in_block.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/object_rename.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/object_rest.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/object_shorthand.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/parameter_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/pattern_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring/single_eval_rhs.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/destructuring_initializer_flow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/getter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/spread_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/spread_tuple.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/tuple.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/diagnostic_counts/unhinted_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/discriminated_union_object_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_callable_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_comments/capability_context_fields.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/duplicate_parameter_names.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_bounds.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_budget_per_run.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_error_taxonomy.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_input_too_long.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_models.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_models_filtered.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_no_provider.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_purpose_invalid.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/embedding_unknown_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/emitter_fallible_healthy.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/emitter_state_healthy.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/empty_array_cast.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/empty_array_cast_non_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/empty_array_never.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enum_member_cases_match_their_own_enum.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enum_member_comparison_narrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enum_member_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enum_negative_zero_initializer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/enum_decl_numeric_typechecks.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/enum_decl_string_typechecks.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/enum_runtime_numeric.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/enum_runtime_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/expect_error_enum_as_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/expect_error_enum_string_missing_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/enums/expect_error_enum_unknown_variant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/equality_comparable_operands.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/equality_literal_operands.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/error_constructor_default_message.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/error_is_error.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/error_is_error_nominal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/error_subclass_object_keys.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/error_subclass_to_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/call_sig_duplicate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/call_sig_not_callable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/default_param_in_fn_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/default_param_type_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/issue_918_partial_catalog.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/new_no_constructor.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/new_no_parens.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/postfix_inc_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/postfix_inc_const.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/errors/postfix_inc_non_numeric.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/break_outside_finally_scope.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/catch_binding_reassign.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/catch_bindingless.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/catch_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/catch_untyped_binds_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/deep_finally_transfers.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/error_default_name.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_bare_throw.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_bare_try.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_catch_any_binding.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/expect_error_throw_non_error.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_caught_path.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_normal_path.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_preserves_pending_completion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_runs_on_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_runs_on_continue.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_runs_on_return.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_transfer_runs_once.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/finally_with_own_return_wins.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_first_match.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/nested_finally_on_return.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/nested_try.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/nested_try_finally_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/return_in_finally_continues_outward.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/throw_caught.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exceptions/throw_in_function_caught_outside.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_annotated_callback_conflict.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_annotated_destructuring_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_annotated_for_of_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_from_array_like_element_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_from_array_like_without_callback.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_from_interface_array_like.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_from_keyed_array_like.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_array_type_after_line_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_arrow_body_and_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_assignment_expression_to_const.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_assignment_reported_once.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_braceless_declaration_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_braceless_declarations.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_break_in_nested_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_callback_param_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_callback_return_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_callback_too_many_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_callback_untyped_extra_param.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_cast_union_without_member_overlap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_class_chain_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_class_in_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_comparable_function_properties.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_comparison_never_true.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_compound_write_reads_base_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_condition_write_after_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_const_literal_operators_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_const_literal_union_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_date_constructor.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_date_now.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_date_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_default_parameter_before_required_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_default_parameter_iife_tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_default_parameter_invalid_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_defaulted_before_required_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_delete_unsupported.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_destructuring_flow_reset.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_destructuring_source_flow_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_do_while_condition_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_duplicate_type_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_empty_array_evolving.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_enum_member_type_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_equality_no_overlap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_error_new_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exponentiation_asserted.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exponentiation_not.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exponentiation_plus.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exponentiation_typeof.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_exponentiation_unary.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_field_does_not_exist.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_arg_contravariant.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_arg_supertype.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_argument_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_method_argument_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_type_argument_variance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_generic_type_size_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_getter_needs_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_getter_without_return_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_if_empty_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_inferred_literal_unknown_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_inferred_literal_weak_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_inferred_type_depth_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_initializer_captured_mutation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_initializer_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_initializer_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_interface_to_string_property.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_interface_to_string_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_const_assigned.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_namespace_read_directly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_variable_inferred_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_later_module_variable_read_directly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_leading_zero_decimal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_legacy_octal_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_literal_type_number_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_literal_type_string_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loop_condition_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_both_sides.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_constant_results.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_parenthesized.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_loose_nullish_void.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_lt_on_boolean.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_map_for_each_param_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_name_after_decimal_point.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nan_comparison.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_duplicate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_missing_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_outer_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_reads_local_below.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_reassigned.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_shadows_param.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_this.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_used_before_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_used_through_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nested_function_write_before_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_nullish_mixed_logical.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_number_plus_string_help.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_numeric_separator.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_object_literal_dictionary_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_object_rest_const_assign.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_object_type_construct_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_chain_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_chain_missing_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_chain_on_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_chain_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_method_body_direct_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_method_super_direct_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_null_field_into_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_optional_parameter_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_parameter_modifier_line_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_parameterless_index_signature.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_cast_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_constructor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_line_break_class_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_line_break_type_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_readonly_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_backreference.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_duplicate_flag.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_invalid_flag.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_invalid_pattern.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_lookahead.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_lookbehind.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_named_backref.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_negative_lookahead.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_negative_lookbehind.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_regex_unterminated.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_required_parameter_after_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_arity_too_few.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_no_annotation.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_non_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_not_last.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_rest_with_default.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_runtime_check_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_runtime_check_locals_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_fallback_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_field_mismatches_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_optional_into_required.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_overwrites_union_tag.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_spread_union_may_be_empty.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_strict_mode_reserved_binding.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_string_at_unnarrowed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_string_or_array_union_method_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_string_plus_number_help.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_string_unknown_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_super_conditional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_super_in_function_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_super_in_nested_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_super_misplaced.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_super_reads_before_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_clause_redeclares_const.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_clause_redeclares_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_syntax_nesting_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_template_nesting_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_this_in_unbound_function_expression.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tostring_wrong_signature.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tostring_wrong_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_arity_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_element_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_empty_rejected.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_index_non_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_index_oob.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_mutators.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_optional_rest_elements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_push.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_tuple_sort.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_args_after_line_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_nesting_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_type_size_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_typeof_invalid_tag.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_typeof_of_a_type_name.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_typeof_unknown_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_unary_minus_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_unary_plus_nullable_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_unclosed_interface_before_export.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_undefined_tuple_spread_required.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_union_literal_assignment_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_union_literal_unknown_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_visibility_after_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_void_compared_with_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_void_condition.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_void_conditional_into_value_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_error_weak_type_no_common_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/exponentiation_grouping.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/field_assignment_flow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/for_of_string_or_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/absence_probing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/append_text.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/bytes_iteration.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/bytes_write_read.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/copy_creates_destination_parents.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/cwd.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/exists_size.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/info_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/linear_remove_move.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/lines_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/lines_iteration.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/list_deep.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/list_entry_shape.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/list_flat.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/list_recursive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/many_handles_recovered.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/max_read_size.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/mkdir_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/move_copy_remove.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/peek_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/peek_crlf.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/read_bytes_range.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/remove_recursive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/root_is_not_a_target.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/stat_kinds.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/text_write_read.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/writer_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/fs/writer_bytes.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_as_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_identity_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_identity_cross_package/lib/extra.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_identity_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_identity_cross_package/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_identity_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_type_rendering_round_trip.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_type_renders_parseable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/function_typed_array_elements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generic_arg_accepts_subclass.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generic_call_infers_common_supertype.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generic_call_infers_from_expected_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generic_type_argument_variance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/array_push_aliased_function.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/array_sort_aliased_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/call_void_return_type_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/callback_parameter_wider_than_element.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/captured_typevar_union_boxed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_box_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_closure_typed_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package/boxes/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_chain/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_chain/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_interface/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_interface/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_namespace/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_cross_package_namespace/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_erased_slot_abi.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_error_subclass.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_extends_concrete_args.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_generic_extends_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_generic_field_rw.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_implements_generic_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_infer_void_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_instanceof.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_instanceof_subclass.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_object_literal_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_recursive_node.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_statics_optional_readonly.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_this_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_two_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_type_arg_shapes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_union_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_universal_slots.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/class_void_type_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_arithmetic_on_t.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_arity_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_arg_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_extends_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_generic_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_instanceof_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_instanceof_args.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_method_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_never_type_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_class_static_type_param.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_conflicting_bindings.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_cross_gp_assignment.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_first_class_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_inference_argument_priority.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_interface_arity.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_method_never_type_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/expect_error_union_member_closely_matched.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/explicit_type_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/first.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_keeps_literal_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_nested_literal_arguments.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_call_widens_fresh_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_calls_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_interface_annotation.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_object_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_recursion.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_union_parameter_naked_priority.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/generic_variance_measured_once.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/identity.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/map_set_aliased_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/nullish_candidates_infer_their_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/object_literal_for_generic_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/recursion.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/returns_generic_closure.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/tostring_on_t.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/tuple_return_generic_fn.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/uninferred_type_param_is_unknown.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/generics/unknown_runtime_descriptor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/global_array_object_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/higher_order_function.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/higher_order_no_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/higher_order_with_capture.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/host_error_catchable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/host_held_values_survive_collection.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/host_owned_vtables.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/host_string_struct_spike.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_get_too_many_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_get_with_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_response_unknown_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http/errors/expect_error_response_unknown_property.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/http_dot_segments.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/alias_named_from.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/embedding_aliased.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/embedding_named.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/embedding_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/embedding_wildcard_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/combined_default_named.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/duplicate_local.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/export_default.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/export_inside_function_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/export_list.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/import_in_function.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/namespace_as_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/namespace_member_as_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/relative_import_escapes_root.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/relative_import_single_file.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/unknown_named.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/unknown_namespace_member.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/unknown_package.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/errors/uuid_not_auto_imported.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/export_modifier_ignored.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/http_namespace_optional_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/import_prelude_namespace_forgiven.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_aliased.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_named.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_package_caller/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_package_caller/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_package_caller/triage/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/llm_wildcard_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_chain/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_chain/inner/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_chain/outer/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_chain/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_closure_callback/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_closure_callback/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/security_check_namespace.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_aliased.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_named.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_package_caller/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_package_caller/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_package_caller/store/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/session_wildcard_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/uuid_aliased.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/uuid_named.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/uuid_namespace.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/uuid_v7.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/imports/uuid_wildcard_namespace.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/inferred_closure_return_widening.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/inferred_literal_extra_fields.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/infinity_nan_parameter_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/inherited_method_lift_substitutes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/initializer_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/initializer_union_shapes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interface_to_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interface_value_capture.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interface_value_into_nullable_object_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interface_value_into_object_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expansive_recursive_assign.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_bad_member_separator.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/interface_property_no_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/single_line_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/structural_object_interface_assign.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/user_interface_decl_typechecks.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/user_interface_factory.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/user_interface_nested_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/user_interface_property_read.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/interfaces/user_interface_value_method_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/is_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/is_primitive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_1147_array_capacity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_1147_push_compatibility.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_821/functions.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_821/optional_functions.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_821/top_level_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_831/cycles.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_831/mixed_cycles.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_836/number_format.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_844/null_algebra.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_844/null_keys.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_872/array_discriminant.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_872/array_guard_boundaries.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_899/expect_error_distinct_enums.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_899/primitive_enum.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_965/global_call_reassignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_966/insert_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_966/inserted_fields_json.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_966/insertion_during_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_966/insertion_preserves_guards.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_968/conditional_loop_writes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_968/nested_loop_writes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_970/accessor_enumeration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/compound_literal_operands.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/conditional_literal_results.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/disjunction_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/enum_literal_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/finally_break_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/finite_alias_depth.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/literal_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/literal_equality_aliases.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/logical_interpolation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/nullable_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/object_spread.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/object_spread_integration.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/object_spread_overrides.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/object_spread_presence.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/polymorphic_covariance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/signed_literal_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/switch_try_termination.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/issue_regressions/void_callback.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/close_called_on_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/close_called_on_exhaustion.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/close_called_on_throw.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterable_hand_rolled.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterator_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterator_continue.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterator_hand_rolled.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/iterator_nullable_t.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/no_close_no_crash.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/iterators/user_interface_iterable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_bare_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_let_json_parse.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_parse_function_target.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_parse_too_many_type_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_parse_type_args_and_as.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_parse_uint8array_target.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_partial_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_stringify_replacer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_stringify_type_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_to_json_wrong_signature.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_to_json_wrong_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/expect_error_unknown_json_member.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/interface_optional_omitted.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/main_array_return.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/main_object_return.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_numbers.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_objects.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_strings.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_tuples.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_array_of_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_as_cast.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_bool.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_diagnostic_preview_path.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_explicit_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_field_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_inferred_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_into_generic_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_into_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_into_interface_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_into_recursive_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_invalid_throws.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_mismatch_throws.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_number_literal_target.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_equals_hash.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_lenient.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_literal_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_nullable_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_optional_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_object_simple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_recursive_discriminated.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_recursive_linked_list.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_recursive_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_recursive_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_string_literal_target.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_t_or_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_tuple_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_tuple_in_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_tuple_literal_position.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_tuple_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_tuple_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_literal_set.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_mixed_tags.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_primitive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_shared_tag.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_status_code.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_tagged.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/parse_union_untagged.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_as_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_bool.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_interface_array_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_interface_optional_field_assigned.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_negative_zero.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_null_valued_nullable_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_nullable_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_nullable_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_nullable_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_object_optional_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_pretty_eval_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_pretty_space_number.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_pretty_space_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/stringify_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/to_json_direct.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/to_json_field_override.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/to_json_field_override_with_capture.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json/to_json_via_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_parse_lone_surrogate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_stringify_collection.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_stringify_erased_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_stringify_reassigned_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_stringify_width_subtype.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/json_utf16_lossless.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/later_module_variable_shadows_namespace.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/let_keeps_regular_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/linear_regex_output.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/linear_string_transforms.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_keeping_operators.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_own_type_keeps_binding_writable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_own_type_under_annotation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_type_capture.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_type_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_type_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_type_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/literal_union_interface_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_batch_ordering.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_batch_partial_failure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_budget_aggregate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_budget_per_execution.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_budget_release_after_trap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_call_erased.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_call_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_error_taxonomy.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_models_all_callable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_models_empty.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_models_filtered.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_models_no_description.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_no_provider.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_prompt_bounds.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_schema_argument_rejected.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_schema_unsupported.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_typed_get.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_typed_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/llm_typed_provider_ignored_schema.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loop_condition_write_narrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loop_empty_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/do_while_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/do_while_continue.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/do_while_once.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/do_while_truthiness_cond.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_continue.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_empty_slots.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_let_per_iteration_binding.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_break.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_continue.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_empty.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_number_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_string_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_of_tuple.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/loops/for_truthiness_cond.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/map_for_each.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/map_from_differing_tuple_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/map_set_from_iterable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/map_set_identity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/basic_string_keys.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/cached_hashes_and_ledger.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/ctor_from_entries.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_for_of_non_iterable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_record_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_weakmap_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_weakmap_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_weakset_type.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/expect_error_weakset_value.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/host_port_roundtrip.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order_after_resize.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order_delete_middle.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order_set.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order_set_after_resize.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/insertion_order_set_delete_middle.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/iterate_for_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/iterate_iterator_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/iterate_set_iterator_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/iterator_concurrent.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/iterator_sees_later_sets.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/keys_values_entries_iterators.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/number_keys.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/object_keys.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/object_values_get_field_access.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/phase2_typecheck.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/phase6_for_of_typecheck.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/postfix_chain_on_new.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/resize.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/set_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/set_ctor_from_values.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/set_host_port_roundtrip.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/set_iterate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/set_keys_values_entries_iterators.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/tombstone_reclamation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/maps/tombstone_reuse.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_constants.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_hypot.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_pi.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_random.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/math_transcendentals.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/method_call_through_string_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/method_lift_substitutes_receiver_args.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/module_let_narrowing_reads_live_after_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/module_variable_before_initialization.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/aliased_enum_import/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/aliased_enum_import/m_enum.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/default_param_cross_module/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/default_param_cross_module/util.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/cycle/b.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/cycle/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/main_decl/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/missing_module/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/private_symbol/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/errors/private_symbol/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_direct_documented/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_direct_missing/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_interface_member/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_internal_helper/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_reexport_missing/util.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_sibling_only/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_docs_sibling_only/util.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_function_type_surface/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/exported_function_type_surface/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/namespace_import/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/namespace_import/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/reexport_basic/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/reexport_basic/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/reserved_word_export_names/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/reserved_word_export_names/values.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/sibling_import/lib.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/sibling_import/util.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/ts_mixed/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/ts_mixed/wrap.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/type_only_reexport/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/type_only_reexport/util.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/union_write_help_unimported_member/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/multi/union_write_help_unimported_member/widget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/mvp_greet.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/namespace_shadowed_by_top_level.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nan_local_binding_not_flagged.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowed_boxed_binding_read.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/aliased_conditions_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/array_isarray_narrows.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/array_isarray_on_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assign_narrowing_survives_join.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assign_narrows_block_tail.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assign_sibling_invalidates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assign_then_call_invalidates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/assignment_value_truthiness.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/call_rereads_field_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/captured_mutator_write_back.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/chained_short_circuit.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/class_field_and_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/class_field_nested_if.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/class_private_field_same_module.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/closure_last_assignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/closure_reguards_field_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/computed_write_retains_literal_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_top_level.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/const_narrow_survives_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/discriminant_kind_equality.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/discriminant_kind_inequality.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/discriminant_member_sets.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/discriminant_three_variants.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/dropped_index_path_hint.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/enum_discriminant_case.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/equality_between_unions.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_continue_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_field_do.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_field_for.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_field_forof.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_field_while.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_finally_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_local_direct.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_local_nested.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_local_switch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_local_try.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_update.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_getter_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_getter_path_cast.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_getter_path_index.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/field_path_two_deep_structural.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_clause_joins.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_condition_preserved.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_do_break.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_for_condition_preserved.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_join_820.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_join_898.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_join_901.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_join_902.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_loops.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_numeric_source.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_switch_unmatched.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/flow_this_for.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/function_union_assignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/generic_class_box_of_box.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/global_field_paths.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/global_guard_mutation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/global_ternary_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/guard_through_an_element.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/immediately_invoked_functions.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/in_operator_basic_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/in_operator_dynamic_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/in_operator_union_filter.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/in_operator_unknown_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/in_typeof_field_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/index_by_constant_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/index_path_and_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/interface_field_holding_class.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_785_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_785_switch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_786.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_816.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_889.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_890_anonymous_lift.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_890_predicate_lift.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_929.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_929_expect_error_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948_composed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948_discriminant.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948_nested.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948_switch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/issue_948_union_refined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/join_points_keep_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/literal_index_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_assignment_result.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_big_bom.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_big_separator.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_boolean_literal_result.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_call_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_function_reference.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_index_conversion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_index_noncanonical.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_json_arguments.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_map_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_builtin_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_class_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_fresh_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_function_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_member_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_number_predicate.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_optional_shape_analysis.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_array_argument/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_array_argument/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_function_reference/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_function_reference/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_imported_global/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_imported_global/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_object_argument/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_object_argument/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_postfix_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_pow_boundary.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_pow_nan.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_generic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_includes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_length.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_receiver_to_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_regex_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_runtime_values.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_search_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_string_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_valueof_conversion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_values_packages/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_values_packages/library/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/live_values_packages/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/loop_exit_body_local_join.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/loop_join_after_continue.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/loop_tail_narrowings.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/loop_wrapped_body_forms.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/nested_block_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/nested_shadow_reuse.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/never_array_hints_later_elements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/never_field_in_object_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/never_operand_in_dead_code.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/never_read_in_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/nominal_union_field_access.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/non_null_assertion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/not_truthiness_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/null_comparison_guards.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/null_eq_else.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/null_global_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/null_neq_then.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/null_neq_unbox.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/nullable_rw_target_write_out.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/nullable_smoke.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/operator_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/postfix_narrowed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_chained_post_if.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_discriminant_post_if.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_eq_else.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_neq_then.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/property_path_neq_then_post_if.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/reassign_same_type_rewidens.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/return_in_if_carries_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/rules_out_every_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/short_circuit_and_narrows.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/short_circuit_or_narrows.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/sibling_paths_three_idents.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/switch_boolean_discriminant.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/switch_without_default_falls_through.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/ternary_and_interface_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/this_rooted_paths.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/truthiness_field_path_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/truthiness_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_aliased_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_boolean_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_field_path_else_branch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_field_path_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_function_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_function_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_number_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_object_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_object_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_string_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_three_way_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/typeof_through_generic_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_discriminant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_else_branch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_generic_strip_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_in_typeof.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_nullable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_primitive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/user_guard_type_alias.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_body_local_continue_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_body_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_break_carries_narrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_break_two_paths_widens.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_fixed_point_continue.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing/while_fixed_point_converges.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/narrowing_field_path_nested_region.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nested_function_default_param.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nested_function_reads_later_local.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nested_function_top_level_block.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/expect_error_never_falls_through.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/expect_error_return_value_in_never_fn.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/expect_error_value_into_never_slot.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/never_assignable_to_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/never_in_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never/never_return_throw.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never_annotated_closure_in_void_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never_function_void_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never_generic_callback.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/never_operands.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/new_uint8array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/new_with_dotted_form.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/no_panic_prelude_invariants.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/null_discriminant_narrows.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullable_receiver_names_the_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/chained.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/simple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/void_right.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/with_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_coalescing/with_parens_ok.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/nullish_grouping_and_zero_literals.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_global_predicates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_parse_statics.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_predicates_no_coercion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_radix_strings.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_static_constants.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_static_predicates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_to_fixed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_to_precision_exponential.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/number_to_string_radix.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/numeric_separators_and_decimal_point.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_function_typed_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_is.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_key_reassigned_wider_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_literal_dictionary_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_literal_evaluation_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_literal_into_nullable_tagged_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_literal_normalization_at_depth.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_literal_subtype_reduction.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_rest_copies.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_rest_let.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_spread_widened_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_statics.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_statics_host.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/object_type_member_named_new.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_field_assign_missing_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_field_assign_non_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_invalid_assign_target.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_union_missing_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/field_assign_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/field_assign_const_binding.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/field_assign_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/field_assign_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/interface_field_assignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/interface_property_write_dispatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/multiline_object_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/nullable_eq_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/nullable_field_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/optional_field_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/optional_field_null_compare.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/optional_present_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/optional_undefined_presence.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/property_shorthand.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/quoted_property_names.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/reserved_keyword_property_names.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/union_field_access.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/widen_to_nullable_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/width_sub_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/width_sub_assign.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/width_sub_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/width_sub_intermediate_arg.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/objects/width_sub_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chain_near_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chain_non_nullable_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chain_nullable_host_property.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chain_string_key.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/chain_then_coalesce.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/field_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/multiple_optional.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/nested_field_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/non_null_division.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/non_null_void_result.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_call_nullable_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_class_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_class_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_class_field_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_generic_method.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_index.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_index_bounds.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_inherited_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_interface_accessor.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_interface_property.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_method_nullable_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_narrowed_step.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_non_null_continuation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_object_prelude_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_primitive_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_redundant_primitive.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_union_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/optional_void_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_chaining/void_result_bindings.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_field_written_null_serializes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_to_json_property.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/optional_to_string_property.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_narrows_return_with_finally.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_returns_into_narrower_slot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_slot_variance.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_variance_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_variance_cross_package/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_variance_cross_package/child/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/override_variance_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_binding_key/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_dynamic_name/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_extra_tag/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_missing_tag/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_payload_key/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_unknown_field/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_unknown_field/types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/class_member_bodies/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/class_missing_return/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/class_unreachable_code/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/doc_callable_members/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/doc_consistency/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/missing_return/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/switch_fallthrough/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/top_level_return/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/unassigned_class_field/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/package_rules/unreachable_code/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_param_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_param_cross_package/host/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_param_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/const_ref_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/const_ref_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/parameter_literal_union_default_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/parse_int_radix_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_bigint.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_captured.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_global.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/postfix_incdec/inc_dec_index.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/expect_error_in_nullable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/expect_error_optional_write_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/expect_error_write_only_implements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/in_accessors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/in_erased_presence.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/in_presence.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/inherited_accessors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/interface_json_surrogates.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/interface_postfix.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/interface_wide_mutation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/postfix_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/postfix_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/postfix_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/recursive_mutation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/required_undefined_round_trip.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/property_regressions/required_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/radix_number_literals.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/assignment_narrows_to_value_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_array_writes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_non_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/getonly_cannot_implement_writable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/inline_object_runtime.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/interface_property_write_rejected.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/object_type_property_write_rejected.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/readonly_array_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly/writable_property_write_ok.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly_cast_qualifiers.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly_rest_parameter.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly_rest_parameter_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/readonly_string_length.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/indexed_growth_and_equality.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/optional_dynamic_presence.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_accessors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_bad_computed_spread.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_checked_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_class_guards.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_conditional_spread.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_errors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_evaluation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_features.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_forward_index.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_function_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_generic_contract_errors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_generic_method_errors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_generic_methods.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_composition.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_composition_errors.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_conflicts.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_forward_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_members.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_inherit_narrow.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_interface_reads.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_literal_writes.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_postfix_checked.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_recursive.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_recursive_interface_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_structural_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/records/record_unions.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_linked_list.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_through_array.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_through_generic_call.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_tree.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/alias_union_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/recursive-types/interface_resolution.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_exec_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_flags_all.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_input_cache.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_lastindex_non_global.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_lastindex_sticky.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_literal_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_named_captures.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_named_captures_unmatched.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_non_ascii_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_numbered_captures.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_per_site_lastindex.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_property_reads.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_shared_input.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_test_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_test_lastindex_global.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_to_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regex_utf16_offsets.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_invalid_flags_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_match_keeps_lone_surrogates.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_missing_source.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_optional_flags.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_replace_split_match_js.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_shorthand_classes_match_js.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rejected_field_write_rhs_hint.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rest_callback_for_fixed_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rest_param_arrow.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rest_param_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rest_param_generic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/rest_param_mixed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/return_paths_void_union_and_getters.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/secrets_main_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_basic.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_cursor_length_budget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_get_erased.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_get_mismatch.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_get_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_list.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_list_cursor_is_sealed.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_list_filtered.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_remove_denied.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_surrogate_fidelity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_typed_get.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/session_unsupported_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/set_algebra.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/set_iteration_parity.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/set_relations.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/shared_serializer_buffer.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/array_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/array_empty_source.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/array_only_spreads.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/err_array_spread_element_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/err_array_spread_non_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/err_object_spread_interface.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/err_object_spread_non_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/object_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/object_multiple_spreads.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/object_override_literal_after.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread/object_override_literal_before.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread_index_signature_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread_into_discriminated_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread_of_conditional_or_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread_of_falsy_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/spread_union_assigned_back.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/static_binding_as_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/strict_mode_reserved_words_as_properties.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_admitted_builders.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_at_nullable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_case.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_char_at.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_code_point_at_out_of_range.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_concat.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_for_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_from_char_code.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_from_char_code_wraps.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_from_code_point.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_index_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_key_member_access.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_length.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_linear_search.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_literal_lone_surrogates.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_match_all.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_match_and_search.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_multiline_raw_newline.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_normalize.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_of_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_ops_keep_lone_surrogates.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_or_array_union_methods.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_ordering.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_pad.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_repeat.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_repeat_negative.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_replace.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_replace_all.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_slice.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_split.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_starts_with.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_trim.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/string_well_formed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_equals_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_equals_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_equals_cross_package/points/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_equals_shape_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_interfaces.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/structural_visit_budget.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/subclass_super_on_every_path.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_assertNever_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_break_in_case.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_break_post_state.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_default_first.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_discriminated_union_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_enum_discriminant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_enum_exhaustive_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_literal_union_default_narrows.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_literal_union_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_multi_label.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_multi_label_discriminated.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_multi_label_literal_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_no_default.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_number_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_return_in_case.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_string_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch/switch_tuple_union_exhaustive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_case_body_recovery_no_panic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_case_hex_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_expression_label_duplicates.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_expression_labels.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_function_declarations_hoisted.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_null_assignment_in_loop.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_nullable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/switch_signed_number_labels.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/syntax_nesting_near_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_generic_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_boolean.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_interface.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_no_substitution.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_non_null_assert.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_nullish.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_number.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_literal_tuple.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_nesting_near_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/template_substitution_spans.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal/fields_bag_by_interface_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_compare.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_compare_sort.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_arithmetic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_compare_from.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_from_iso.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_host_validation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_like_arg.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_object_literal.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_round_total.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_sign.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_to_string_options.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_with_abs_blank.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_duration_zdt_anchor.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_error_messages.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_errors_are_catchable.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_getters.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_hook_contract.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_arithmetic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_equals.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_from_epoch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_iso_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_instant_round.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_long_duration.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_negative_duration.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_now_plain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_now_smoke.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_now_time_zone_id.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_now_zoned_date_time_iso.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_numeric_range_validation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_options_interface_arg.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plain_arithmetic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plain_erased_boundaries.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plain_to_zoned.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plaindate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plaindate_to_plaindatetime.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plaindatetime.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plainmonthday.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plaintime.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_plainyearmonth.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_to_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_until_options.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_with.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_alias_identity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_dst_spring_forward.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_equals.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_from_iso.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_host_complete.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_to_instant.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_to_plain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zdt_with_time_zone.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/temporal_zoned_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/expect_error_missing_colon.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/logical_branches.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/simple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/truthiness_cond.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/void_branches.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ternary/with_optional_chain.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/text_codec_unicode.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/text_codec_with_base64.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/text_encoder_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/to_json_record_non_string_throws.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/top_level_function_identity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tostring_default_still_works.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tostring_field_override.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tostring_field_override_with_capture.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/trailing_commas.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/always_truthy.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/and_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/bigint_cond.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/boolean_or_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/false_branch_keeps_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/logical_in_condition.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/number_cond.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/or_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/string_cond.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness/string_or_null_empty.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/truthiness_rules_out_to_never.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/ts_single.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_as_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_as_iterable_source.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_in_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_json_stringify.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_labels.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_length.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_methods.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuple_union_index_access.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/issue_988_arity.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/issue_988_correlation.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/issue_988_union_context.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/optional_elements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/tuples/required_undefined_to_optional.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/alias_null_in_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/alias_string_host_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/alias_tuple_literal_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/alias_union_dedup.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/aliased_function_type_const.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/aliased_void_return.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/aliased_void_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/generic_alias_box.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/generic_alias_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/generic_alias_pair.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/non_generic_alias_nested.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/type_alias_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/type_alias_discriminated_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/type_alias_object.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/type_alias_primitive.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type-aliases/type_alias_union.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type_guard_rendering_names_the_loss.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type_member_line_breaks.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type_members_named_like_keywords.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/type_size_near_limit.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/typeof_alone.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/typeof_enum_member.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/typeof_function_narrows_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/typeof_type_query.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/typeof_undefined_type_query.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/types/expect_error_any_not_supported.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/types/expect_error_bare_function_type_params.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/types/expect_error_function_type_param_typo.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/types/expect_error_unclosed_grouped_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/types/parenthesized_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_alloc.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_at.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_base64.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_base64_options.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_byte_length.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_copy_within.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_equals.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_fill.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_filter.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_find.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_for_each.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_from_array.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_from_bytes.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_from_hex_errors.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_hex.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_host_vtable.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_index_bounds.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_index_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_indexed_write.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_join.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_map.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_new.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_new_length.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_of.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_ranged_mutations.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_reduce.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_reverse.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_set.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_set_out_of_range.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_slice.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_some_every.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_sort.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_subarray.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_to_json.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_to_reversed.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_to_sorted.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_to_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_truncate.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_with.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uint8array_wraps_like_to_uint8.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unary_plus_string.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/expect_error_required.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/expect_error_required_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/methods.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/primitives.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined/properties.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_array_literal_elements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_array_literal_nullish_lead.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_base_constructor_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_class_method_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_class_to_json_alias.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_closure_returns.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_collections.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_default_parameter_write_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_destructuring_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_function_optional_compatibility.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_generic_union_inference.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_inferred_parameter_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_json.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_later_destructured_parameter_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_later_inferred_default.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/guards.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/nullish_discriminants.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/optional_chain.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/singleton_comparisons.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_narrowing/typeof_void.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_native_optional_methods.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_optional_method_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_optional_method_implements.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_default_source_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_default_tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_defaults.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_destructuring_order.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_pattern_capture.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_pattern_literal_types.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_pattern_write.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_property_declared_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_property_inferred_type.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_parameter_tdz.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_return_completion.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_runtime.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_strings.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_temporal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_tuple_spread.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/undefined_tuple_union.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unicode_whitespace_and_slash_escape.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_cross_type_eq.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_field_write_named_fix_round_trip.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_field_write_names_the_fix.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_field_write_names_the_narrowing.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_field_write_non_union_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_field_write_unnarrowable_receiver.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_literal_known_fields.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_member_lowering_nullability.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/union_primitive_eq.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/array_isarray.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/array_isarray_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/array_isarray_null_runtime.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/closure_returns_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/contextual_closure_returns_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/eq_literal.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/eq_null.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_and_or.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_arithmetic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_body_never_returns.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_call.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_field_access.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_index_access.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_ordering.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/expect_error_truthiness.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/generic_null_arg.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/no_value_cross_package/app/main.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/no_value_cross_package/packages.manifest (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/no_value_returns_null.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/null_into_unknown.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/parameter_round_trip.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/short_circuit.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/tostring.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown/typeof_narrowing.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/unknown_array_null_element.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uri_encode_decode.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/uri_error_builtin.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/build_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/build_host_only.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/encode_decode_component.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/encode_decode_query.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/field_narrowing_guard.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_empty_query.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_host_trailing_dot.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_invalid_type_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_no_fragment.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_no_port.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_query_encoded.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/parse_query_multiple.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/url/query_type_alias.subm (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_accessor_nested_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_array_element_generic_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_array_element_shorthand_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_as_generic_arg_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_behind_warning_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_class_field_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_class_static_field_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_closure_param_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_conditional_cast_and_json_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_conditional_in_comparisons_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_equality_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_function_param_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_function_type_alias_param_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_function_type_param_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_hint_diverging_closure.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_inferred_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_interface_method_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_interface_property_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_interface_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_into_value_slot_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_literal_element_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_nullish_left_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_object_field_type_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_recursive_interface_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_recursive_permutation_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_return_position.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_return_type_argument.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_setter_param_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_switch_discriminant_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_tuple_element_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_union_condition.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_union_member_value.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/void_value_annotations.ts (100%) rename crates/{submilli-engine => interpreter}/tests/fixtures/weak_type_shared_field.ts (100%) rename crates/{submilli-engine => interpreter}/tests/git_memory.rs (100%) rename crates/{submilli-engine => interpreter}/tests/host_memory.rs (100%) rename crates/{submilli-engine => interpreter}/tests/http_live.rs (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/download_basic.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/download_gzip_decompress.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/get_200_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/get_404.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/headers_authorization.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/headers_missing_auth_returns_404.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/json_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/json_method.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_array_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_null_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_object_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_object_body_custom_ct.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_string_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_uint8array_body.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/post_undefined_body.ts (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/put_string_body_ct_override.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/request_runtime_verb.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/response_to_string.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_live_fixtures/verb_matrix.subm (100%) rename crates/{submilli-engine => interpreter}/tests/http_tls_fixtures/ca.pem (100%) rename crates/{submilli-engine => interpreter}/tests/http_tls_fixtures/localhost-key.pem (100%) rename crates/{submilli-engine => interpreter}/tests/http_tls_fixtures/localhost.pem (100%) rename crates/{submilli-engine => interpreter}/tests/lexer_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/memory_caps.rs (100%) rename crates/{submilli-engine => interpreter}/tests/namespace_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/object_vtable_dispatch.rs (100%) rename crates/{submilli-engine => interpreter}/tests/package_diagnostic_snapshots.rs (100%) rename crates/{submilli-engine => interpreter}/tests/parser_depth.rs (100%) rename crates/{submilli-engine => interpreter}/tests/record_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap (95%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap (86%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap (84%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap (95%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap (78%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap (93%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap (92%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap (90%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap (87%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap (79%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap (79%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap (83%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap (80%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap (78%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap (80%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap (88%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap (86%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap (85%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap (86%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap (74%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap (77%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap (89%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap (82%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap (82%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap (94%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap (94%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap (87%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap (92%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap (78%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap (82%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap (80%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap (88%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap (79%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap (75%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap (84%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap (85%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap (86%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap (89%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap (90%) rename crates/{submilli-engine => interpreter}/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap (87%) rename crates/{submilli-engine => interpreter}/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap (94%) rename crates/{submilli-engine => interpreter}/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap (94%) rename crates/{submilli-engine => interpreter}/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap (95%) rename crates/{submilli-engine => interpreter}/tests/substitution_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/traps_in_callbacks.rs (100%) rename crates/{submilli-engine => interpreter}/tests/type_limits.rs (100%) rename crates/{submilli-engine => interpreter}/tests/vfs_containment.rs (100%) delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap delete mode 100644 crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap diff --git a/AGENTS.md b/AGENTS.md index a6a1ccf45..64feda709 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -84,7 +84,7 @@ Compile errors should include source context, a caret, relevant type or function signatures, and an actionable fix. Thread source spans through every compiler phase. When adding or removing a gated capability, update -[the capability catalog](crates/submilli-engine/src/stdlib/capabilities.rs) in the same +[the capability catalog](crates/interpreter/src/stdlib/capabilities.rs) in the same change, including its summary, filter fields, and example filter. Blueprint scaffolding reads this catalog. @@ -154,7 +154,7 @@ violations. Apply these exceptions when following review and no-panic workflows. Fuel bounds the CPU a program spends, wherever it spends it. Wasm instructions burn fuel by themselves. A host function (a standard-library or prelude function implemented in Rust) must charge for its own work from the same budget, through -`crates/submilli-engine/src/runtime/fuel.rs`. A host function that charges nothing +`crates/interpreter/src/runtime/fuel.rs`. A host function that charges nothing is a free loop for any program. **Host work is discounted.** One fuel is about 2.5 ns, the cost of one @@ -297,7 +297,7 @@ final release candidate before publication. Enable the flag during development only for focused verification of changes to these tests or their selection, and for the Git standard-library checks below. -Whenever modifying the Git standard library (`crates/submilli-engine/src/stdlib/git/`), +Whenever modifying the Git standard library (`crates/interpreter/src/stdlib/git/`), run the Git memory-limit tests in addition to other affected checks: ```sh diff --git a/Cargo.toml b/Cargo.toml index 7167b39c8..591eb95a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,7 +2,7 @@ resolver = "3" members = [ "crates/conformance", - "crates/submilli-engine", + "crates/interpreter", "crates/submilli", "crates/submilli-build", "crates/submilli-blueprint", diff --git a/crates/conformance/Cargo.toml b/crates/conformance/Cargo.toml index 2e5332dc9..fa40f8a12 100644 --- a/crates/conformance/Cargo.toml +++ b/crates/conformance/Cargo.toml @@ -10,6 +10,6 @@ publish.workspace = true workspace = true [dev-dependencies] -interpreter = { package = "submilli-engine", path = "../submilli-engine" } +interpreter = { package = "submilli-engine", path = "../interpreter" } tokio = { workspace = true, features = ["rt"] } wasmtime = { workspace = true } diff --git a/crates/conformance/typescript/README.md b/crates/conformance/typescript/README.md index 7f35c0346..595a040a0 100644 --- a/crates/conformance/typescript/README.md +++ b/crates/conformance/typescript/README.md @@ -419,7 +419,7 @@ from the retained program. These are typechecker comparisons, not runtime tests: declaration placeholders are intentionally not executed. The executable Record regressions live in the -[interpreter fixtures](../../submilli-engine/tests/fixtures/records/). +[interpreter fixtures](../../interpreter/tests/fixtures/records/). The generic dictionary local uses `{}` instead of the usual placeholder cast, because casting to an erased generic parameter is unsupported. Both compilers retain its declared index value type `T`. diff --git a/crates/submilli-engine/Cargo.toml b/crates/interpreter/Cargo.toml similarity index 100% rename from crates/submilli-engine/Cargo.toml rename to crates/interpreter/Cargo.toml diff --git a/crates/submilli-engine/README.md b/crates/interpreter/README.md similarity index 100% rename from crates/submilli-engine/README.md rename to crates/interpreter/README.md diff --git a/crates/submilli-engine/build.rs b/crates/interpreter/build.rs similarity index 100% rename from crates/submilli-engine/build.rs rename to crates/interpreter/build.rs diff --git a/crates/submilli-engine/src/arena.rs b/crates/interpreter/src/arena.rs similarity index 100% rename from crates/submilli-engine/src/arena.rs rename to crates/interpreter/src/arena.rs diff --git a/crates/submilli-engine/src/artifact_f64.rs b/crates/interpreter/src/artifact_f64.rs similarity index 100% rename from crates/submilli-engine/src/artifact_f64.rs rename to crates/interpreter/src/artifact_f64.rs diff --git a/crates/submilli-engine/src/asi.rs b/crates/interpreter/src/asi.rs similarity index 100% rename from crates/submilli-engine/src/asi.rs rename to crates/interpreter/src/asi.rs diff --git a/crates/submilli-engine/src/ast.rs b/crates/interpreter/src/ast.rs similarity index 100% rename from crates/submilli-engine/src/ast.rs rename to crates/interpreter/src/ast.rs diff --git a/crates/submilli-engine/src/authority.rs b/crates/interpreter/src/authority.rs similarity index 100% rename from crates/submilli-engine/src/authority.rs rename to crates/interpreter/src/authority.rs diff --git a/crates/submilli-engine/src/backtrace.rs b/crates/interpreter/src/backtrace.rs similarity index 100% rename from crates/submilli-engine/src/backtrace.rs rename to crates/interpreter/src/backtrace.rs diff --git a/crates/submilli-engine/src/capability_derivation.rs b/crates/interpreter/src/capability_derivation.rs similarity index 100% rename from crates/submilli-engine/src/capability_derivation.rs rename to crates/interpreter/src/capability_derivation.rs diff --git a/crates/submilli-engine/src/codegen/analysis.rs b/crates/interpreter/src/codegen/analysis.rs similarity index 100% rename from crates/submilli-engine/src/codegen/analysis.rs rename to crates/interpreter/src/codegen/analysis.rs diff --git a/crates/submilli-engine/src/codegen/argument_defaults.rs b/crates/interpreter/src/codegen/argument_defaults.rs similarity index 100% rename from crates/submilli-engine/src/codegen/argument_defaults.rs rename to crates/interpreter/src/codegen/argument_defaults.rs diff --git a/crates/submilli-engine/src/codegen/bigint_pool.rs b/crates/interpreter/src/codegen/bigint_pool.rs similarity index 100% rename from crates/submilli-engine/src/codegen/bigint_pool.rs rename to crates/interpreter/src/codegen/bigint_pool.rs diff --git a/crates/submilli-engine/src/codegen/bounds.rs b/crates/interpreter/src/codegen/bounds.rs similarity index 100% rename from crates/submilli-engine/src/codegen/bounds.rs rename to crates/interpreter/src/codegen/bounds.rs diff --git a/crates/submilli-engine/src/codegen/box_types.rs b/crates/interpreter/src/codegen/box_types.rs similarity index 100% rename from crates/submilli-engine/src/codegen/box_types.rs rename to crates/interpreter/src/codegen/box_types.rs diff --git a/crates/submilli-engine/src/codegen/call_arguments.rs b/crates/interpreter/src/codegen/call_arguments.rs similarity index 100% rename from crates/submilli-engine/src/codegen/call_arguments.rs rename to crates/interpreter/src/codegen/call_arguments.rs diff --git a/crates/submilli-engine/src/codegen/cast_check.rs b/crates/interpreter/src/codegen/cast_check.rs similarity index 100% rename from crates/submilli-engine/src/codegen/cast_check.rs rename to crates/interpreter/src/codegen/cast_check.rs diff --git a/crates/submilli-engine/src/codegen/cast_diagnostics.rs b/crates/interpreter/src/codegen/cast_diagnostics.rs similarity index 100% rename from crates/submilli-engine/src/codegen/cast_diagnostics.rs rename to crates/interpreter/src/codegen/cast_diagnostics.rs diff --git a/crates/submilli-engine/src/codegen/classes.rs b/crates/interpreter/src/codegen/classes.rs similarity index 100% rename from crates/submilli-engine/src/codegen/classes.rs rename to crates/interpreter/src/codegen/classes.rs diff --git a/crates/submilli-engine/src/codegen/closure_coercions.rs b/crates/interpreter/src/codegen/closure_coercions.rs similarity index 100% rename from crates/submilli-engine/src/codegen/closure_coercions.rs rename to crates/interpreter/src/codegen/closure_coercions.rs diff --git a/crates/submilli-engine/src/codegen/closures.rs b/crates/interpreter/src/codegen/closures.rs similarity index 100% rename from crates/submilli-engine/src/codegen/closures.rs rename to crates/interpreter/src/codegen/closures.rs diff --git a/crates/submilli-engine/src/codegen/dependency_usage.rs b/crates/interpreter/src/codegen/dependency_usage.rs similarity index 100% rename from crates/submilli-engine/src/codegen/dependency_usage.rs rename to crates/interpreter/src/codegen/dependency_usage.rs diff --git a/crates/submilli-engine/src/codegen/dwarf.rs b/crates/interpreter/src/codegen/dwarf.rs similarity index 100% rename from crates/submilli-engine/src/codegen/dwarf.rs rename to crates/interpreter/src/codegen/dwarf.rs diff --git a/crates/submilli-engine/src/codegen/field_guards.rs b/crates/interpreter/src/codegen/field_guards.rs similarity index 100% rename from crates/submilli-engine/src/codegen/field_guards.rs rename to crates/interpreter/src/codegen/field_guards.rs diff --git a/crates/submilli-engine/src/codegen/field_lookup.rs b/crates/interpreter/src/codegen/field_lookup.rs similarity index 100% rename from crates/submilli-engine/src/codegen/field_lookup.rs rename to crates/interpreter/src/codegen/field_lookup.rs diff --git a/crates/submilli-engine/src/codegen/field_name_strings.rs b/crates/interpreter/src/codegen/field_name_strings.rs similarity index 100% rename from crates/submilli-engine/src/codegen/field_name_strings.rs rename to crates/interpreter/src/codegen/field_name_strings.rs diff --git a/crates/submilli-engine/src/codegen/field_names.rs b/crates/interpreter/src/codegen/field_names.rs similarity index 100% rename from crates/submilli-engine/src/codegen/field_names.rs rename to crates/interpreter/src/codegen/field_names.rs diff --git a/crates/submilli-engine/src/codegen/function_adapters.rs b/crates/interpreter/src/codegen/function_adapters.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_adapters.rs rename to crates/interpreter/src/codegen/function_adapters.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/binding_cells.rs b/crates/interpreter/src/codegen/function_emitter/binding_cells.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/binding_cells.rs rename to crates/interpreter/src/codegen/function_emitter/binding_cells.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/cast.rs b/crates/interpreter/src/codegen/function_emitter/cast.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/cast.rs rename to crates/interpreter/src/codegen/function_emitter/cast.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/expr.rs b/crates/interpreter/src/codegen/function_emitter/expr.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/expr.rs rename to crates/interpreter/src/codegen/function_emitter/expr.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/finally.rs b/crates/interpreter/src/codegen/function_emitter/finally.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/finally.rs rename to crates/interpreter/src/codegen/function_emitter/finally.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/json.rs b/crates/interpreter/src/codegen/function_emitter/json.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/json.rs rename to crates/interpreter/src/codegen/function_emitter/json.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/mcp.rs b/crates/interpreter/src/codegen/function_emitter/mcp.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/mcp.rs rename to crates/interpreter/src/codegen/function_emitter/mcp.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/mod.rs b/crates/interpreter/src/codegen/function_emitter/mod.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/mod.rs rename to crates/interpreter/src/codegen/function_emitter/mod.rs diff --git a/crates/submilli-engine/src/codegen/function_emitter/stmt.rs b/crates/interpreter/src/codegen/function_emitter/stmt.rs similarity index 100% rename from crates/submilli-engine/src/codegen/function_emitter/stmt.rs rename to crates/interpreter/src/codegen/function_emitter/stmt.rs diff --git a/crates/submilli-engine/src/codegen/imported_classes.rs b/crates/interpreter/src/codegen/imported_classes.rs similarity index 100% rename from crates/submilli-engine/src/codegen/imported_classes.rs rename to crates/interpreter/src/codegen/imported_classes.rs diff --git a/crates/submilli-engine/src/codegen/init_guard.rs b/crates/interpreter/src/codegen/init_guard.rs similarity index 100% rename from crates/submilli-engine/src/codegen/init_guard.rs rename to crates/interpreter/src/codegen/init_guard.rs diff --git a/crates/submilli-engine/src/codegen/intrinsics.rs b/crates/interpreter/src/codegen/intrinsics.rs similarity index 100% rename from crates/submilli-engine/src/codegen/intrinsics.rs rename to crates/interpreter/src/codegen/intrinsics.rs diff --git a/crates/submilli-engine/src/codegen/invariant_tests.rs b/crates/interpreter/src/codegen/invariant_tests.rs similarity index 100% rename from crates/submilli-engine/src/codegen/invariant_tests.rs rename to crates/interpreter/src/codegen/invariant_tests.rs diff --git a/crates/submilli-engine/src/codegen/mod.rs b/crates/interpreter/src/codegen/mod.rs similarity index 100% rename from crates/submilli-engine/src/codegen/mod.rs rename to crates/interpreter/src/codegen/mod.rs diff --git a/crates/submilli-engine/src/codegen/nullish.rs b/crates/interpreter/src/codegen/nullish.rs similarity index 100% rename from crates/submilli-engine/src/codegen/nullish.rs rename to crates/interpreter/src/codegen/nullish.rs diff --git a/crates/submilli-engine/src/codegen/recursive_validators.rs b/crates/interpreter/src/codegen/recursive_validators.rs similarity index 100% rename from crates/submilli-engine/src/codegen/recursive_validators.rs rename to crates/interpreter/src/codegen/recursive_validators.rs diff --git a/crates/submilli-engine/src/codegen/runtime_descriptors.rs b/crates/interpreter/src/codegen/runtime_descriptors.rs similarity index 100% rename from crates/submilli-engine/src/codegen/runtime_descriptors.rs rename to crates/interpreter/src/codegen/runtime_descriptors.rs diff --git a/crates/submilli-engine/src/codegen/runtime_values.rs b/crates/interpreter/src/codegen/runtime_values.rs similarity index 100% rename from crates/submilli-engine/src/codegen/runtime_values.rs rename to crates/interpreter/src/codegen/runtime_values.rs diff --git a/crates/submilli-engine/src/codegen/runtime_values/declarations.rs b/crates/interpreter/src/codegen/runtime_values/declarations.rs similarity index 100% rename from crates/submilli-engine/src/codegen/runtime_values/declarations.rs rename to crates/interpreter/src/codegen/runtime_values/declarations.rs diff --git a/crates/submilli-engine/src/codegen/runtime_values/flow.rs b/crates/interpreter/src/codegen/runtime_values/flow.rs similarity index 100% rename from crates/submilli-engine/src/codegen/runtime_values/flow.rs rename to crates/interpreter/src/codegen/runtime_values/flow.rs diff --git a/crates/submilli-engine/src/codegen/runtime_values/rewrite.rs b/crates/interpreter/src/codegen/runtime_values/rewrite.rs similarity index 100% rename from crates/submilli-engine/src/codegen/runtime_values/rewrite.rs rename to crates/interpreter/src/codegen/runtime_values/rewrite.rs diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap similarity index 78% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap index 7544d882d..126987720 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__assert_false_throws_with_backtrace.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs expression: dump --- error: Error: oops diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap similarity index 95% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap index 834454d1d..2953cef40 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__closure_method_accessor_and_constructor_frames_are_named.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs assertion_line: 5147 expression: dump --- diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap similarity index 89% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap index 107917427..7794d310b 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__code_after_a_cast_keeps_its_backtrace_location.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap similarity index 92% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap index cf832d626..4b53f98e6 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_die_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs assertion_line: 4927 expression: dump --- diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap similarity index 93% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap index ea01bb546..aa162f204 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_covers_helper.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs assertion_line: 5058 expression: dump --- diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap similarity index 93% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap index 821af9ad2..58b9e35a1 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_line_program_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs assertion_line: 5043 expression: dump --- diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap similarity index 94% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap index 1d0a318fc..a1a35939b 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__dwarf_subprograms_for_each_user_function.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs assertion_line: 5013 expression: dump --- diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap similarity index 80% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap index c56613d30..4df265c4b 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__failed_cast_backtrace_points_at_the_cast.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs expression: dump --- error: TypeError: type mismatch: expected P, got object at $["a"] diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap similarity index 88% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap index 78d9dc171..891bd212f 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__multi_frame_backtrace.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap similarity index 92% rename from crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap rename to crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap index c7428efbc..ec458bd24 100644 --- a/crates/submilli-engine/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap +++ b/crates/interpreter/src/codegen/snapshots/submilli_engine__codegen__tests__three_frame_backtrace_labels_caller_in_middle.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/codegen/mod.rs +source: crates/interpreter/src/codegen/mod.rs expression: dump --- error: Error: x diff --git a/crates/submilli-engine/src/codegen/string_pool.rs b/crates/interpreter/src/codegen/string_pool.rs similarity index 100% rename from crates/submilli-engine/src/codegen/string_pool.rs rename to crates/interpreter/src/codegen/string_pool.rs diff --git a/crates/submilli-engine/src/codegen/symbol_table.rs b/crates/interpreter/src/codegen/symbol_table.rs similarity index 100% rename from crates/submilli-engine/src/codegen/symbol_table.rs rename to crates/interpreter/src/codegen/symbol_table.rs diff --git a/crates/submilli-engine/src/codegen/this_binding.rs b/crates/interpreter/src/codegen/this_binding.rs similarity index 100% rename from crates/submilli-engine/src/codegen/this_binding.rs rename to crates/interpreter/src/codegen/this_binding.rs diff --git a/crates/submilli-engine/src/codegen/throw.rs b/crates/interpreter/src/codegen/throw.rs similarity index 100% rename from crates/submilli-engine/src/codegen/throw.rs rename to crates/interpreter/src/codegen/throw.rs diff --git a/crates/submilli-engine/src/codegen/user_subtypes.rs b/crates/interpreter/src/codegen/user_subtypes.rs similarity index 100% rename from crates/submilli-engine/src/codegen/user_subtypes.rs rename to crates/interpreter/src/codegen/user_subtypes.rs diff --git a/crates/submilli-engine/src/codegen/vtable_walk.rs b/crates/interpreter/src/codegen/vtable_walk.rs similarity index 100% rename from crates/submilli-engine/src/codegen/vtable_walk.rs rename to crates/interpreter/src/codegen/vtable_walk.rs diff --git a/crates/submilli-engine/src/compile.rs b/crates/interpreter/src/compile.rs similarity index 100% rename from crates/submilli-engine/src/compile.rs rename to crates/interpreter/src/compile.rs diff --git a/crates/submilli-engine/src/compile_capabilities.rs b/crates/interpreter/src/compile_capabilities.rs similarity index 100% rename from crates/submilli-engine/src/compile_capabilities.rs rename to crates/interpreter/src/compile_capabilities.rs diff --git a/crates/submilli-engine/src/compiler_error.rs b/crates/interpreter/src/compiler_error.rs similarity index 100% rename from crates/submilli-engine/src/compiler_error.rs rename to crates/interpreter/src/compiler_error.rs diff --git a/crates/submilli-engine/src/compiler_limits.rs b/crates/interpreter/src/compiler_limits.rs similarity index 100% rename from crates/submilli-engine/src/compiler_limits.rs rename to crates/interpreter/src/compiler_limits.rs diff --git a/crates/submilli-engine/src/diagnostics.rs b/crates/interpreter/src/diagnostics.rs similarity index 100% rename from crates/submilli-engine/src/diagnostics.rs rename to crates/interpreter/src/diagnostics.rs diff --git a/crates/submilli-engine/src/did_you_mean.rs b/crates/interpreter/src/did_you_mean.rs similarity index 100% rename from crates/submilli-engine/src/did_you_mean.rs rename to crates/interpreter/src/did_you_mean.rs diff --git a/crates/submilli-engine/src/doc_comment.rs b/crates/interpreter/src/doc_comment.rs similarity index 100% rename from crates/submilli-engine/src/doc_comment.rs rename to crates/interpreter/src/doc_comment.rs diff --git a/crates/submilli-engine/src/lexer.rs b/crates/interpreter/src/lexer.rs similarity index 100% rename from crates/submilli-engine/src/lexer.rs rename to crates/interpreter/src/lexer.rs diff --git a/crates/submilli-engine/src/lib.rs b/crates/interpreter/src/lib.rs similarity index 100% rename from crates/submilli-engine/src/lib.rs rename to crates/interpreter/src/lib.rs diff --git a/crates/submilli-engine/src/literal_units.rs b/crates/interpreter/src/literal_units.rs similarity index 100% rename from crates/submilli-engine/src/literal_units.rs rename to crates/interpreter/src/literal_units.rs diff --git a/crates/submilli-engine/src/lower_patterns.rs b/crates/interpreter/src/lower_patterns.rs similarity index 100% rename from crates/submilli-engine/src/lower_patterns.rs rename to crates/interpreter/src/lower_patterns.rs diff --git a/crates/submilli-engine/src/mangle.rs b/crates/interpreter/src/mangle.rs similarity index 100% rename from crates/submilli-engine/src/mangle.rs rename to crates/interpreter/src/mangle.rs diff --git a/crates/submilli-engine/src/package_declaration.rs b/crates/interpreter/src/package_declaration.rs similarity index 100% rename from crates/submilli-engine/src/package_declaration.rs rename to crates/interpreter/src/package_declaration.rs diff --git a/crates/submilli-engine/src/packages.rs b/crates/interpreter/src/packages.rs similarity index 100% rename from crates/submilli-engine/src/packages.rs rename to crates/interpreter/src/packages.rs diff --git a/crates/submilli-engine/src/parser.rs b/crates/interpreter/src/parser.rs similarity index 100% rename from crates/submilli-engine/src/parser.rs rename to crates/interpreter/src/parser.rs diff --git a/crates/submilli-engine/src/rendering.rs b/crates/interpreter/src/rendering.rs similarity index 100% rename from crates/submilli-engine/src/rendering.rs rename to crates/interpreter/src/rendering.rs diff --git a/crates/submilli-engine/src/runtime/agents.rs b/crates/interpreter/src/runtime/agents.rs similarity index 100% rename from crates/submilli-engine/src/runtime/agents.rs rename to crates/interpreter/src/runtime/agents.rs diff --git a/crates/submilli-engine/src/runtime/array_storage.rs b/crates/interpreter/src/runtime/array_storage.rs similarity index 100% rename from crates/submilli-engine/src/runtime/array_storage.rs rename to crates/interpreter/src/runtime/array_storage.rs diff --git a/crates/submilli-engine/src/runtime/blocking.rs b/crates/interpreter/src/runtime/blocking.rs similarity index 100% rename from crates/submilli-engine/src/runtime/blocking.rs rename to crates/interpreter/src/runtime/blocking.rs diff --git a/crates/submilli-engine/src/runtime/call_log.rs b/crates/interpreter/src/runtime/call_log.rs similarity index 100% rename from crates/submilli-engine/src/runtime/call_log.rs rename to crates/interpreter/src/runtime/call_log.rs diff --git a/crates/submilli-engine/src/runtime/decision.rs b/crates/interpreter/src/runtime/decision.rs similarity index 100% rename from crates/submilli-engine/src/runtime/decision.rs rename to crates/interpreter/src/runtime/decision.rs diff --git a/crates/submilli-engine/src/runtime/disk_quota.rs b/crates/interpreter/src/runtime/disk_quota.rs similarity index 100% rename from crates/submilli-engine/src/runtime/disk_quota.rs rename to crates/interpreter/src/runtime/disk_quota.rs diff --git a/crates/submilli-engine/src/runtime/embedding.rs b/crates/interpreter/src/runtime/embedding.rs similarity index 100% rename from crates/submilli-engine/src/runtime/embedding.rs rename to crates/interpreter/src/runtime/embedding.rs diff --git a/crates/submilli-engine/src/runtime/exec.rs b/crates/interpreter/src/runtime/exec.rs similarity index 100% rename from crates/submilli-engine/src/runtime/exec.rs rename to crates/interpreter/src/runtime/exec.rs diff --git a/crates/submilli-engine/src/runtime/fs.rs b/crates/interpreter/src/runtime/fs.rs similarity index 100% rename from crates/submilli-engine/src/runtime/fs.rs rename to crates/interpreter/src/runtime/fs.rs diff --git a/crates/submilli-engine/src/runtime/fs/removal.rs b/crates/interpreter/src/runtime/fs/removal.rs similarity index 100% rename from crates/submilli-engine/src/runtime/fs/removal.rs rename to crates/interpreter/src/runtime/fs/removal.rs diff --git a/crates/submilli-engine/src/runtime/fuel.rs b/crates/interpreter/src/runtime/fuel.rs similarity index 100% rename from crates/submilli-engine/src/runtime/fuel.rs rename to crates/interpreter/src/runtime/fuel.rs diff --git a/crates/submilli-engine/src/runtime/gc_singleton.rs b/crates/interpreter/src/runtime/gc_singleton.rs similarity index 100% rename from crates/submilli-engine/src/runtime/gc_singleton.rs rename to crates/interpreter/src/runtime/gc_singleton.rs diff --git a/crates/submilli-engine/src/runtime/host.rs b/crates/interpreter/src/runtime/host.rs similarity index 100% rename from crates/submilli-engine/src/runtime/host.rs rename to crates/interpreter/src/runtime/host.rs diff --git a/crates/submilli-engine/src/runtime/intrinsic_types.rs b/crates/interpreter/src/runtime/intrinsic_types.rs similarity index 100% rename from crates/submilli-engine/src/runtime/intrinsic_types.rs rename to crates/interpreter/src/runtime/intrinsic_types.rs diff --git a/crates/submilli-engine/src/runtime/json.rs b/crates/interpreter/src/runtime/json.rs similarity index 100% rename from crates/submilli-engine/src/runtime/json.rs rename to crates/interpreter/src/runtime/json.rs diff --git a/crates/submilli-engine/src/runtime/json/format.rs b/crates/interpreter/src/runtime/json/format.rs similarity index 100% rename from crates/submilli-engine/src/runtime/json/format.rs rename to crates/interpreter/src/runtime/json/format.rs diff --git a/crates/submilli-engine/src/runtime/json_text.rs b/crates/interpreter/src/runtime/json_text.rs similarity index 100% rename from crates/submilli-engine/src/runtime/json_text.rs rename to crates/interpreter/src/runtime/json_text.rs diff --git a/crates/submilli-engine/src/runtime/limits.rs b/crates/interpreter/src/runtime/limits.rs similarity index 100% rename from crates/submilli-engine/src/runtime/limits.rs rename to crates/interpreter/src/runtime/limits.rs diff --git a/crates/submilli-engine/src/runtime/llm.rs b/crates/interpreter/src/runtime/llm.rs similarity index 100% rename from crates/submilli-engine/src/runtime/llm.rs rename to crates/interpreter/src/runtime/llm.rs diff --git a/crates/submilli-engine/src/runtime/mcp.rs b/crates/interpreter/src/runtime/mcp.rs similarity index 100% rename from crates/submilli-engine/src/runtime/mcp.rs rename to crates/interpreter/src/runtime/mcp.rs diff --git a/crates/submilli-engine/src/runtime/mcp/response.rs b/crates/interpreter/src/runtime/mcp/response.rs similarity index 100% rename from crates/submilli-engine/src/runtime/mcp/response.rs rename to crates/interpreter/src/runtime/mcp/response.rs diff --git a/crates/submilli-engine/src/runtime/metrics.rs b/crates/interpreter/src/runtime/metrics.rs similarity index 100% rename from crates/submilli-engine/src/runtime/metrics.rs rename to crates/interpreter/src/runtime/metrics.rs diff --git a/crates/submilli-engine/src/runtime/mod.rs b/crates/interpreter/src/runtime/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/mod.rs rename to crates/interpreter/src/runtime/mod.rs diff --git a/crates/submilli-engine/src/runtime/number.rs b/crates/interpreter/src/runtime/number.rs similarity index 100% rename from crates/submilli-engine/src/runtime/number.rs rename to crates/interpreter/src/runtime/number.rs diff --git a/crates/submilli-engine/src/runtime/prelude/arguments.rs b/crates/interpreter/src/runtime/prelude/arguments.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/arguments.rs rename to crates/interpreter/src/runtime/prelude/arguments.rs diff --git a/crates/submilli-engine/src/runtime/prelude/array/install.rs b/crates/interpreter/src/runtime/prelude/array/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/array/install.rs rename to crates/interpreter/src/runtime/prelude/array/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/array/mod.rs b/crates/interpreter/src/runtime/prelude/array/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/array/mod.rs rename to crates/interpreter/src/runtime/prelude/array/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/array/sort.rs b/crates/interpreter/src/runtime/prelude/array/sort.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/array/sort.rs rename to crates/interpreter/src/runtime/prelude/array/sort.rs diff --git a/crates/submilli-engine/src/runtime/prelude/bigint/mod.rs b/crates/interpreter/src/runtime/prelude/bigint/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/bigint/mod.rs rename to crates/interpreter/src/runtime/prelude/bigint/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/bigint/ops.rs b/crates/interpreter/src/runtime/prelude/bigint/ops.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/bigint/ops.rs rename to crates/interpreter/src/runtime/prelude/bigint/ops.rs diff --git a/crates/submilli-engine/src/runtime/prelude/bitwise.rs b/crates/interpreter/src/runtime/prelude/bitwise.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/bitwise.rs rename to crates/interpreter/src/runtime/prelude/bitwise.rs diff --git a/crates/submilli-engine/src/runtime/prelude/boolean/mod.rs b/crates/interpreter/src/runtime/prelude/boolean/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/boolean/mod.rs rename to crates/interpreter/src/runtime/prelude/boolean/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/closure.rs b/crates/interpreter/src/runtime/prelude/closure.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/closure.rs rename to crates/interpreter/src/runtime/prelude/closure.rs diff --git a/crates/submilli-engine/src/runtime/prelude/collection.rs b/crates/interpreter/src/runtime/prelude/collection.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/collection.rs rename to crates/interpreter/src/runtime/prelude/collection.rs diff --git a/crates/submilli-engine/src/runtime/prelude/console.rs b/crates/interpreter/src/runtime/prelude/console.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/console.rs rename to crates/interpreter/src/runtime/prelude/console.rs diff --git a/crates/submilli-engine/src/runtime/prelude/declaration.rs b/crates/interpreter/src/runtime/prelude/declaration.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/declaration.rs rename to crates/interpreter/src/runtime/prelude/declaration.rs diff --git a/crates/submilli-engine/src/runtime/prelude/error.rs b/crates/interpreter/src/runtime/prelude/error.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/error.rs rename to crates/interpreter/src/runtime/prelude/error.rs diff --git a/crates/submilli-engine/src/runtime/prelude/iterator/mod.rs b/crates/interpreter/src/runtime/prelude/iterator/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/iterator/mod.rs rename to crates/interpreter/src/runtime/prelude/iterator/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/keep.rs b/crates/interpreter/src/runtime/prelude/keep.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/keep.rs rename to crates/interpreter/src/runtime/prelude/keep.rs diff --git a/crates/submilli-engine/src/runtime/prelude/ledger.rs b/crates/interpreter/src/runtime/prelude/ledger.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/ledger.rs rename to crates/interpreter/src/runtime/prelude/ledger.rs diff --git a/crates/submilli-engine/src/runtime/prelude/map/install.rs b/crates/interpreter/src/runtime/prelude/map/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/map/install.rs rename to crates/interpreter/src/runtime/prelude/map/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/map/mod.rs b/crates/interpreter/src/runtime/prelude/map/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/map/mod.rs rename to crates/interpreter/src/runtime/prelude/map/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/math.rs b/crates/interpreter/src/runtime/prelude/math.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/math.rs rename to crates/interpreter/src/runtime/prelude/math.rs diff --git a/crates/submilli-engine/src/runtime/prelude/member.rs b/crates/interpreter/src/runtime/prelude/member.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/member.rs rename to crates/interpreter/src/runtime/prelude/member.rs diff --git a/crates/submilli-engine/src/runtime/prelude/mod.rs b/crates/interpreter/src/runtime/prelude/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/mod.rs rename to crates/interpreter/src/runtime/prelude/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/number/mod.rs b/crates/interpreter/src/runtime/prelude/number/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/number/mod.rs rename to crates/interpreter/src/runtime/prelude/number/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/object/dynamic.rs b/crates/interpreter/src/runtime/prelude/object/dynamic.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/object/dynamic.rs rename to crates/interpreter/src/runtime/prelude/object/dynamic.rs diff --git a/crates/submilli-engine/src/runtime/prelude/object/index.rs b/crates/interpreter/src/runtime/prelude/object/index.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/object/index.rs rename to crates/interpreter/src/runtime/prelude/object/index.rs diff --git a/crates/submilli-engine/src/runtime/prelude/object/mod.rs b/crates/interpreter/src/runtime/prelude/object/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/object/mod.rs rename to crates/interpreter/src/runtime/prelude/object/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/object/static_value.rs b/crates/interpreter/src/runtime/prelude/object/static_value.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/object/static_value.rs rename to crates/interpreter/src/runtime/prelude/object/static_value.rs diff --git a/crates/submilli-engine/src/runtime/prelude/regex/engine.rs b/crates/interpreter/src/runtime/prelude/regex/engine.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/regex/engine.rs rename to crates/interpreter/src/runtime/prelude/regex/engine.rs diff --git a/crates/submilli-engine/src/runtime/prelude/regex/input.rs b/crates/interpreter/src/runtime/prelude/regex/input.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/regex/input.rs rename to crates/interpreter/src/runtime/prelude/regex/input.rs diff --git a/crates/submilli-engine/src/runtime/prelude/regex/install.rs b/crates/interpreter/src/runtime/prelude/regex/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/regex/install.rs rename to crates/interpreter/src/runtime/prelude/regex/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/regex/mod.rs b/crates/interpreter/src/runtime/prelude/regex/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/regex/mod.rs rename to crates/interpreter/src/runtime/prelude/regex/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/regex/output.rs b/crates/interpreter/src/runtime/prelude/regex/output.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/regex/output.rs rename to crates/interpreter/src/runtime/prelude/regex/output.rs diff --git a/crates/submilli-engine/src/runtime/prelude/set/install.rs b/crates/interpreter/src/runtime/prelude/set/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/set/install.rs rename to crates/interpreter/src/runtime/prelude/set/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/set/mod.rs b/crates/interpreter/src/runtime/prelude/set/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/set/mod.rs rename to crates/interpreter/src/runtime/prelude/set/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/string/install.rs b/crates/interpreter/src/runtime/prelude/string/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/string/install.rs rename to crates/interpreter/src/runtime/prelude/string/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/string/mod.rs b/crates/interpreter/src/runtime/prelude/string/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/string/mod.rs rename to crates/interpreter/src/runtime/prelude/string/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/string/search.rs b/crates/interpreter/src/runtime/prelude/string/search.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/string/search.rs rename to crates/interpreter/src/runtime/prelude/string/search.rs diff --git a/crates/submilli-engine/src/runtime/prelude/string/transforms.rs b/crates/interpreter/src/runtime/prelude/string/transforms.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/string/transforms.rs rename to crates/interpreter/src/runtime/prelude/string/transforms.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/duration/install.rs b/crates/interpreter/src/runtime/prelude/temporal/duration/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/duration/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/duration/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/duration/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/duration/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/duration/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/duration/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/instant/install.rs b/crates/interpreter/src/runtime/prelude/temporal/instant/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/instant/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/instant/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/instant/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/instant/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/instant/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/instant/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/now/install.rs b/crates/interpreter/src/runtime/prelude/temporal/now/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/now/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/now/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/now/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/now/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/now/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/now/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_date/install.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_date/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_date/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_date/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_date/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_date/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_date/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_date/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/install.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_date_time/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_date_time/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_date_time/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_date_time/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_date_time/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/install.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_month_day/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_month_day/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_month_day/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_month_day/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_month_day/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_time/install.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_time/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_time/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_time/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_time/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_time/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_time/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_time/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/install.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_year_month/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_year_month/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/plain_year_month/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/plain_year_month/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/plain_year_month/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/shared.rs b/crates/interpreter/src/runtime/prelude/temporal/shared.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/shared.rs rename to crates/interpreter/src/runtime/prelude/temporal/shared.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE b/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE rename to crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/CLDR-LICENSE diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/install.rs b/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/install.rs rename to crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/mod.rs b/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/mod.rs rename to crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs b/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs rename to crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_cache.rs diff --git a/crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs b/crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs rename to crates/interpreter/src/runtime/prelude/temporal/zoned_date_time/zone_ids.rs diff --git a/crates/submilli-engine/src/runtime/prelude/textcodec/install.rs b/crates/interpreter/src/runtime/prelude/textcodec/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/textcodec/install.rs rename to crates/interpreter/src/runtime/prelude/textcodec/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/textcodec/mod.rs b/crates/interpreter/src/runtime/prelude/textcodec/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/textcodec/mod.rs rename to crates/interpreter/src/runtime/prelude/textcodec/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/uint8array/install.rs b/crates/interpreter/src/runtime/prelude/uint8array/install.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/uint8array/install.rs rename to crates/interpreter/src/runtime/prelude/uint8array/install.rs diff --git a/crates/submilli-engine/src/runtime/prelude/uint8array/mod.rs b/crates/interpreter/src/runtime/prelude/uint8array/mod.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/uint8array/mod.rs rename to crates/interpreter/src/runtime/prelude/uint8array/mod.rs diff --git a/crates/submilli-engine/src/runtime/prelude/undefined.rs b/crates/interpreter/src/runtime/prelude/undefined.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/undefined.rs rename to crates/interpreter/src/runtime/prelude/undefined.rs diff --git a/crates/submilli-engine/src/runtime/prelude/uri.rs b/crates/interpreter/src/runtime/prelude/uri.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/uri.rs rename to crates/interpreter/src/runtime/prelude/uri.rs diff --git a/crates/submilli-engine/src/runtime/prelude/value.rs b/crates/interpreter/src/runtime/prelude/value.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/value.rs rename to crates/interpreter/src/runtime/prelude/value.rs diff --git a/crates/submilli-engine/src/runtime/prelude/vtable.rs b/crates/interpreter/src/runtime/prelude/vtable.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/vtable.rs rename to crates/interpreter/src/runtime/prelude/vtable.rs diff --git a/crates/submilli-engine/src/runtime/prelude/vtable/serialization.rs b/crates/interpreter/src/runtime/prelude/vtable/serialization.rs similarity index 100% rename from crates/submilli-engine/src/runtime/prelude/vtable/serialization.rs rename to crates/interpreter/src/runtime/prelude/vtable/serialization.rs diff --git a/crates/submilli-engine/src/runtime/secrets.rs b/crates/interpreter/src/runtime/secrets.rs similarity index 100% rename from crates/submilli-engine/src/runtime/secrets.rs rename to crates/interpreter/src/runtime/secrets.rs diff --git a/crates/submilli-engine/src/runtime/security.rs b/crates/interpreter/src/runtime/security.rs similarity index 100% rename from crates/submilli-engine/src/runtime/security.rs rename to crates/interpreter/src/runtime/security.rs diff --git a/crates/submilli-engine/src/runtime/session_kv.rs b/crates/interpreter/src/runtime/session_kv.rs similarity index 100% rename from crates/submilli-engine/src/runtime/session_kv.rs rename to crates/interpreter/src/runtime/session_kv.rs diff --git a/crates/submilli-engine/src/runtime/skills.rs b/crates/interpreter/src/runtime/skills.rs similarity index 100% rename from crates/submilli-engine/src/runtime/skills.rs rename to crates/interpreter/src/runtime/skills.rs diff --git a/crates/submilli-engine/src/runtime/token_ledger.rs b/crates/interpreter/src/runtime/token_ledger.rs similarity index 100% rename from crates/submilli-engine/src/runtime/token_ledger.rs rename to crates/interpreter/src/runtime/token_ledger.rs diff --git a/crates/submilli-engine/src/runtime/vfs.rs b/crates/interpreter/src/runtime/vfs.rs similarity index 100% rename from crates/submilli-engine/src/runtime/vfs.rs rename to crates/interpreter/src/runtime/vfs.rs diff --git a/crates/submilli-engine/src/runtime/watchdog.rs b/crates/interpreter/src/runtime/watchdog.rs similarity index 100% rename from crates/submilli-engine/src/runtime/watchdog.rs rename to crates/interpreter/src/runtime/watchdog.rs diff --git a/crates/submilli-engine/src/shape.rs b/crates/interpreter/src/shape.rs similarity index 100% rename from crates/submilli-engine/src/shape.rs rename to crates/interpreter/src/shape.rs diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap b/crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap similarity index 95% rename from crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap rename to crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap index a57901c53..463d212c2 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__asi__tests__mvp_fixture_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/asi.rs +source: crates/interpreter/src/asi.rs expression: kinds --- [ diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap similarity index 73% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap index bc7d0bc1e..2503603fd 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_eof.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: boom diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap similarity index 73% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap index c2b3d3a70..4b461495f 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_clamps_at_sof.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: boom diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap similarity index 87% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap index 5a5f3cdea..243452a87 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multi_note_error_with_gutter_alignment.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: missing return in all code paths diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap similarity index 81% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap index b1420fce1..1a9230c7b 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiline_span_carets.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: multi-line span diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap similarity index 77% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap index a61db6a97..0ffd33f6d 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_multiple_helps.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: bad diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap similarity index 82% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap index 6371f6ecd..121f4d61c 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_single_line_error.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: type mismatch: expected `number`, found `string` diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap similarity index 77% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap index 851dd7ff5..ea6c2a12d 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_warning_severity.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- warning: unused variable `unused` diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap similarity index 82% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap index eed3d1b41..4d6dcc735 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: field `bar` does not exist on `Foo` diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap similarity index 82% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap index 23a4bc0f0..34af24c86 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_with_help_and_notes.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: bad diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap similarity index 73% rename from crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap rename to crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap index 12d95c5d4..71e7634f3 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__diagnostics__tests__render_zero_length_span_at_eof.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/diagnostics.rs +source: crates/interpreter/src/diagnostics.rs expression: "render(&diag, \"script.subm\", source, &line_index)" --- error: expected `;` diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap similarity index 69% rename from crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap index 35d37b310..d02ccc179 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_bare_exponent_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/lexer.rs +source: crates/interpreter/src/lexer.rs expression: rendered --- error: missing digits in exponent diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap similarity index 74% rename from crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap index 29d60f293..dbc2c65d5 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_string_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/lexer.rs +source: crates/interpreter/src/lexer.rs expression: rendered --- error: unterminated string literal diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap similarity index 74% rename from crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap index 38b04481d..bb1f71c2f 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__renders_unterminated_template_diagnostic.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/lexer.rs +source: crates/interpreter/src/lexer.rs expression: rendered --- error: unterminated template literal diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap similarity index 96% rename from crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap rename to crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap index 1062c8d4b..683b3edc6 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__lexer__tests__tokenize_mvp_fixture.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/lexer.rs +source: crates/interpreter/src/lexer.rs expression: kinds --- [ diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap index ac3a6532d..5f9f81d60 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__full_precedence_chain_snapshot.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap index 6e9213715..6f6f07e60 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__parse_sequence_of_atoms.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap similarity index 98% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap index fbde7e4f2..d0719edaf 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_else_if_chain.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap index fc2c6e23f..adde97d35 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_declaration.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap index e39ec8969..be4d1d6b8 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_if_and_return.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap index c9e5f2bda..6fd9dee39 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_function_with_while.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap index 66b80bc7b..7dd968c68 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_mixed_declarations.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap index 3e4c9fa30..5edf162a3 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_call_program.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap similarity index 88% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap index 860f7cae4..a42dd3de3 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_multi_error_render.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: rendered --- error: expected `;` after expression diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap similarity index 98% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap index f81d5fc12..4afc06bb3 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_object_and_array_literals.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap similarity index 99% rename from crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap rename to crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap index 37cdb333d..40378203f 100644 --- a/crates/submilli-engine/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap +++ b/crates/interpreter/src/snapshots/submilli_engine__parser__tests__snapshot_union_type_mix.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/parser.rs +source: crates/interpreter/src/parser.rs expression: ast --- Ast { diff --git a/crates/submilli-engine/src/source.rs b/crates/interpreter/src/source.rs similarity index 100% rename from crates/submilli-engine/src/source.rs rename to crates/interpreter/src/source.rs diff --git a/crates/submilli-engine/src/source_validation.rs b/crates/interpreter/src/source_validation.rs similarity index 100% rename from crates/submilli-engine/src/source_validation.rs rename to crates/interpreter/src/source_validation.rs diff --git a/crates/submilli-engine/src/span.rs b/crates/interpreter/src/span.rs similarity index 100% rename from crates/submilli-engine/src/span.rs rename to crates/interpreter/src/span.rs diff --git a/crates/submilli-engine/src/stdlib/abi.rs b/crates/interpreter/src/stdlib/abi.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/abi.rs rename to crates/interpreter/src/stdlib/abi.rs diff --git a/crates/submilli-engine/src/stdlib/agents/declaration.rs b/crates/interpreter/src/stdlib/agents/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/agents/declaration.rs rename to crates/interpreter/src/stdlib/agents/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/agents/mod.rs b/crates/interpreter/src/stdlib/agents/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/agents/mod.rs rename to crates/interpreter/src/stdlib/agents/mod.rs diff --git a/crates/submilli-engine/src/stdlib/capabilities.rs b/crates/interpreter/src/stdlib/capabilities.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/capabilities.rs rename to crates/interpreter/src/stdlib/capabilities.rs diff --git a/crates/submilli-engine/src/stdlib/code/budget.rs b/crates/interpreter/src/stdlib/code/budget.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/budget.rs rename to crates/interpreter/src/stdlib/code/budget.rs diff --git a/crates/submilli-engine/src/stdlib/code/declaration.rs b/crates/interpreter/src/stdlib/code/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/declaration.rs rename to crates/interpreter/src/stdlib/code/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/code/mod.rs b/crates/interpreter/src/stdlib/code/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/mod.rs rename to crates/interpreter/src/stdlib/code/mod.rs diff --git a/crates/submilli-engine/src/stdlib/code/myers.rs b/crates/interpreter/src/stdlib/code/myers.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/myers.rs rename to crates/interpreter/src/stdlib/code/myers.rs diff --git a/crates/submilli-engine/src/stdlib/code/patch.rs b/crates/interpreter/src/stdlib/code/patch.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/patch.rs rename to crates/interpreter/src/stdlib/code/patch.rs diff --git a/crates/submilli-engine/src/stdlib/code/tests.rs b/crates/interpreter/src/stdlib/code/tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/tests.rs rename to crates/interpreter/src/stdlib/code/tests.rs diff --git a/crates/submilli-engine/src/stdlib/code/text.rs b/crates/interpreter/src/stdlib/code/text.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/text.rs rename to crates/interpreter/src/stdlib/code/text.rs diff --git a/crates/submilli-engine/src/stdlib/code/walk.rs b/crates/interpreter/src/stdlib/code/walk.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/code/walk.rs rename to crates/interpreter/src/stdlib/code/walk.rs diff --git a/crates/submilli-engine/src/stdlib/crypto.rs b/crates/interpreter/src/stdlib/crypto.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/crypto.rs rename to crates/interpreter/src/stdlib/crypto.rs diff --git a/crates/submilli-engine/src/stdlib/dot_segments.rs b/crates/interpreter/src/stdlib/dot_segments.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/dot_segments.rs rename to crates/interpreter/src/stdlib/dot_segments.rs diff --git a/crates/submilli-engine/src/stdlib/embedding/declaration.rs b/crates/interpreter/src/stdlib/embedding/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/embedding/declaration.rs rename to crates/interpreter/src/stdlib/embedding/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/embedding/mod.rs b/crates/interpreter/src/stdlib/embedding/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/embedding/mod.rs rename to crates/interpreter/src/stdlib/embedding/mod.rs diff --git a/crates/submilli-engine/src/stdlib/fs/declaration.rs b/crates/interpreter/src/stdlib/fs/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/fs/declaration.rs rename to crates/interpreter/src/stdlib/fs/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/fs/handles.rs b/crates/interpreter/src/stdlib/fs/handles.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/fs/handles.rs rename to crates/interpreter/src/stdlib/fs/handles.rs diff --git a/crates/submilli-engine/src/stdlib/fs/mod.rs b/crates/interpreter/src/stdlib/fs/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/fs/mod.rs rename to crates/interpreter/src/stdlib/fs/mod.rs diff --git a/crates/submilli-engine/src/stdlib/git/class.rs b/crates/interpreter/src/stdlib/git/class.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/class.rs rename to crates/interpreter/src/stdlib/git/class.rs diff --git a/crates/submilli-engine/src/stdlib/git/declaration.rs b/crates/interpreter/src/stdlib/git/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/declaration.rs rename to crates/interpreter/src/stdlib/git/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/git/diff.rs b/crates/interpreter/src/stdlib/git/diff.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/diff.rs rename to crates/interpreter/src/stdlib/git/diff.rs diff --git a/crates/submilli-engine/src/stdlib/git/history.rs b/crates/interpreter/src/stdlib/git/history.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/history.rs rename to crates/interpreter/src/stdlib/git/history.rs diff --git a/crates/submilli-engine/src/stdlib/git/index_limits.rs b/crates/interpreter/src/stdlib/git/index_limits.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/index_limits.rs rename to crates/interpreter/src/stdlib/git/index_limits.rs diff --git a/crates/submilli-engine/src/stdlib/git/integration_tests.rs b/crates/interpreter/src/stdlib/git/integration_tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/integration_tests.rs rename to crates/interpreter/src/stdlib/git/integration_tests.rs diff --git a/crates/submilli-engine/src/stdlib/git/location.rs b/crates/interpreter/src/stdlib/git/location.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/location.rs rename to crates/interpreter/src/stdlib/git/location.rs diff --git a/crates/submilli-engine/src/stdlib/git/lock.rs b/crates/interpreter/src/stdlib/git/lock.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/lock.rs rename to crates/interpreter/src/stdlib/git/lock.rs diff --git a/crates/submilli-engine/src/stdlib/git/log_cache.rs b/crates/interpreter/src/stdlib/git/log_cache.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/log_cache.rs rename to crates/interpreter/src/stdlib/git/log_cache.rs diff --git a/crates/submilli-engine/src/stdlib/git/metadata_scan.rs b/crates/interpreter/src/stdlib/git/metadata_scan.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/metadata_scan.rs rename to crates/interpreter/src/stdlib/git/metadata_scan.rs diff --git a/crates/submilli-engine/src/stdlib/git/meter.rs b/crates/interpreter/src/stdlib/git/meter.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/meter.rs rename to crates/interpreter/src/stdlib/git/meter.rs diff --git a/crates/submilli-engine/src/stdlib/git/mod.rs b/crates/interpreter/src/stdlib/git/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/mod.rs rename to crates/interpreter/src/stdlib/git/mod.rs diff --git a/crates/submilli-engine/src/stdlib/git/object.rs b/crates/interpreter/src/stdlib/git/object.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/object.rs rename to crates/interpreter/src/stdlib/git/object.rs diff --git a/crates/submilli-engine/src/stdlib/git/operations.rs b/crates/interpreter/src/stdlib/git/operations.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/operations.rs rename to crates/interpreter/src/stdlib/git/operations.rs diff --git a/crates/submilli-engine/src/stdlib/git/pack_index_check.rs b/crates/interpreter/src/stdlib/git/pack_index_check.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/pack_index_check.rs rename to crates/interpreter/src/stdlib/git/pack_index_check.rs diff --git a/crates/submilli-engine/src/stdlib/git/pack_limits.rs b/crates/interpreter/src/stdlib/git/pack_limits.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/pack_limits.rs rename to crates/interpreter/src/stdlib/git/pack_limits.rs diff --git a/crates/submilli-engine/src/stdlib/git/stage.rs b/crates/interpreter/src/stdlib/git/stage.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/stage.rs rename to crates/interpreter/src/stdlib/git/stage.rs diff --git a/crates/submilli-engine/src/stdlib/git/storage.rs b/crates/interpreter/src/stdlib/git/storage.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/storage.rs rename to crates/interpreter/src/stdlib/git/storage.rs diff --git a/crates/submilli-engine/src/stdlib/git/tests.rs b/crates/interpreter/src/stdlib/git/tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/tests.rs rename to crates/interpreter/src/stdlib/git/tests.rs diff --git a/crates/submilli-engine/src/stdlib/git/transport.rs b/crates/interpreter/src/stdlib/git/transport.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/transport.rs rename to crates/interpreter/src/stdlib/git/transport.rs diff --git a/crates/submilli-engine/src/stdlib/git/work.rs b/crates/interpreter/src/stdlib/git/work.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/work.rs rename to crates/interpreter/src/stdlib/git/work.rs diff --git a/crates/submilli-engine/src/stdlib/git/worker.rs b/crates/interpreter/src/stdlib/git/worker.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/git/worker.rs rename to crates/interpreter/src/stdlib/git/worker.rs diff --git a/crates/submilli-engine/src/stdlib/http/declaration.rs b/crates/interpreter/src/stdlib/http/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/declaration.rs rename to crates/interpreter/src/stdlib/http/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/http/mod.rs b/crates/interpreter/src/stdlib/http/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/mod.rs rename to crates/interpreter/src/stdlib/http/mod.rs diff --git a/crates/submilli-engine/src/stdlib/http/policy.rs b/crates/interpreter/src/stdlib/http/policy.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/policy.rs rename to crates/interpreter/src/stdlib/http/policy.rs diff --git a/crates/submilli-engine/src/stdlib/http/redirect_guard.rs b/crates/interpreter/src/stdlib/http/redirect_guard.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/redirect_guard.rs rename to crates/interpreter/src/stdlib/http/redirect_guard.rs diff --git a/crates/submilli-engine/src/stdlib/http/transport.rs b/crates/interpreter/src/stdlib/http/transport.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/transport.rs rename to crates/interpreter/src/stdlib/http/transport.rs diff --git a/crates/submilli-engine/src/stdlib/http/transport_policy.rs b/crates/interpreter/src/stdlib/http/transport_policy.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/transport_policy.rs rename to crates/interpreter/src/stdlib/http/transport_policy.rs diff --git a/crates/submilli-engine/src/stdlib/http/transport_policy_tests.rs b/crates/interpreter/src/stdlib/http/transport_policy_tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/transport_policy_tests.rs rename to crates/interpreter/src/stdlib/http/transport_policy_tests.rs diff --git a/crates/submilli-engine/src/stdlib/http/transport_tls_tests.rs b/crates/interpreter/src/stdlib/http/transport_tls_tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/http/transport_tls_tests.rs rename to crates/interpreter/src/stdlib/http/transport_tls_tests.rs diff --git a/crates/submilli-engine/src/stdlib/llm/declaration.rs b/crates/interpreter/src/stdlib/llm/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/llm/declaration.rs rename to crates/interpreter/src/stdlib/llm/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/llm/mod.rs b/crates/interpreter/src/stdlib/llm/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/llm/mod.rs rename to crates/interpreter/src/stdlib/llm/mod.rs diff --git a/crates/submilli-engine/src/stdlib/mod.rs b/crates/interpreter/src/stdlib/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/mod.rs rename to crates/interpreter/src/stdlib/mod.rs diff --git a/crates/submilli-engine/src/stdlib/optional_tests.rs b/crates/interpreter/src/stdlib/optional_tests.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/optional_tests.rs rename to crates/interpreter/src/stdlib/optional_tests.rs diff --git a/crates/submilli-engine/src/stdlib/secrets.rs b/crates/interpreter/src/stdlib/secrets.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/secrets.rs rename to crates/interpreter/src/stdlib/secrets.rs diff --git a/crates/submilli-engine/src/stdlib/security.rs b/crates/interpreter/src/stdlib/security.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/security.rs rename to crates/interpreter/src/stdlib/security.rs diff --git a/crates/submilli-engine/src/stdlib/session/cursor.rs b/crates/interpreter/src/stdlib/session/cursor.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/session/cursor.rs rename to crates/interpreter/src/stdlib/session/cursor.rs diff --git a/crates/submilli-engine/src/stdlib/session/declaration.rs b/crates/interpreter/src/stdlib/session/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/session/declaration.rs rename to crates/interpreter/src/stdlib/session/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/session/mod.rs b/crates/interpreter/src/stdlib/session/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/session/mod.rs rename to crates/interpreter/src/stdlib/session/mod.rs diff --git a/crates/submilli-engine/src/stdlib/session/value.rs b/crates/interpreter/src/stdlib/session/value.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/session/value.rs rename to crates/interpreter/src/stdlib/session/value.rs diff --git a/crates/submilli-engine/src/stdlib/shared.rs b/crates/interpreter/src/stdlib/shared.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/shared.rs rename to crates/interpreter/src/stdlib/shared.rs diff --git a/crates/submilli-engine/src/stdlib/skills/declaration.rs b/crates/interpreter/src/stdlib/skills/declaration.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/skills/declaration.rs rename to crates/interpreter/src/stdlib/skills/declaration.rs diff --git a/crates/submilli-engine/src/stdlib/skills/mod.rs b/crates/interpreter/src/stdlib/skills/mod.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/skills/mod.rs rename to crates/interpreter/src/stdlib/skills/mod.rs diff --git a/crates/submilli-engine/src/stdlib/test.rs b/crates/interpreter/src/stdlib/test.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/test.rs rename to crates/interpreter/src/stdlib/test.rs diff --git a/crates/submilli-engine/src/stdlib/url.rs b/crates/interpreter/src/stdlib/url.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/url.rs rename to crates/interpreter/src/stdlib/url.rs diff --git a/crates/submilli-engine/src/stdlib/uuid.rs b/crates/interpreter/src/stdlib/uuid.rs similarity index 100% rename from crates/submilli-engine/src/stdlib/uuid.rs rename to crates/interpreter/src/stdlib/uuid.rs diff --git a/crates/submilli-engine/src/token.rs b/crates/interpreter/src/token.rs similarity index 100% rename from crates/submilli-engine/src/token.rs rename to crates/interpreter/src/token.rs diff --git a/crates/submilli-engine/src/tree_height.rs b/crates/interpreter/src/tree_height.rs similarity index 100% rename from crates/submilli-engine/src/tree_height.rs rename to crates/interpreter/src/tree_height.rs diff --git a/crates/submilli-engine/src/type_info.rs b/crates/interpreter/src/type_info.rs similarity index 100% rename from crates/submilli-engine/src/type_info.rs rename to crates/interpreter/src/type_info.rs diff --git a/crates/submilli-engine/src/type_rendering.rs b/crates/interpreter/src/type_rendering.rs similarity index 100% rename from crates/submilli-engine/src/type_rendering.rs rename to crates/interpreter/src/type_rendering.rs diff --git a/crates/submilli-engine/src/type_size.rs b/crates/interpreter/src/type_size.rs similarity index 100% rename from crates/submilli-engine/src/type_size.rs rename to crates/interpreter/src/type_size.rs diff --git a/crates/submilli-engine/src/type_walk.rs b/crates/interpreter/src/type_walk.rs similarity index 100% rename from crates/submilli-engine/src/type_walk.rs rename to crates/interpreter/src/type_walk.rs diff --git a/crates/submilli-engine/src/typechecker/capture.rs b/crates/interpreter/src/typechecker/capture.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/capture.rs rename to crates/interpreter/src/typechecker/capture.rs diff --git a/crates/submilli-engine/src/typechecker/desugar/do_while.rs b/crates/interpreter/src/typechecker/desugar/do_while.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/desugar/do_while.rs rename to crates/interpreter/src/typechecker/desugar/do_while.rs diff --git a/crates/submilli-engine/src/typechecker/desugar/for_loop.rs b/crates/interpreter/src/typechecker/desugar/for_loop.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/desugar/for_loop.rs rename to crates/interpreter/src/typechecker/desugar/for_loop.rs diff --git a/crates/submilli-engine/src/typechecker/desugar/for_of.rs b/crates/interpreter/src/typechecker/desugar/for_of.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/desugar/for_of.rs rename to crates/interpreter/src/typechecker/desugar/for_of.rs diff --git a/crates/submilli-engine/src/typechecker/desugar/mod.rs b/crates/interpreter/src/typechecker/desugar/mod.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/desugar/mod.rs rename to crates/interpreter/src/typechecker/desugar/mod.rs diff --git a/crates/submilli-engine/src/typechecker/desugar/postfix_incdec.rs b/crates/interpreter/src/typechecker/desugar/postfix_incdec.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/desugar/postfix_incdec.rs rename to crates/interpreter/src/typechecker/desugar/postfix_incdec.rs diff --git a/crates/submilli-engine/src/typechecker/infer/aliased_conditions.rs b/crates/interpreter/src/typechecker/infer/aliased_conditions.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/aliased_conditions.rs rename to crates/interpreter/src/typechecker/infer/aliased_conditions.rs diff --git a/crates/submilli-engine/src/typechecker/infer/assign_expr.rs b/crates/interpreter/src/typechecker/infer/assign_expr.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/assign_expr.rs rename to crates/interpreter/src/typechecker/infer/assign_expr.rs diff --git a/crates/submilli-engine/src/typechecker/infer/assignable.rs b/crates/interpreter/src/typechecker/infer/assignable.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/assignable.rs rename to crates/interpreter/src/typechecker/infer/assignable.rs diff --git a/crates/submilli-engine/src/typechecker/infer/best_common_type.rs b/crates/interpreter/src/typechecker/infer/best_common_type.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/best_common_type.rs rename to crates/interpreter/src/typechecker/infer/best_common_type.rs diff --git a/crates/submilli-engine/src/typechecker/infer/binding_analysis.rs b/crates/interpreter/src/typechecker/infer/binding_analysis.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/binding_analysis.rs rename to crates/interpreter/src/typechecker/infer/binding_analysis.rs diff --git a/crates/submilli-engine/src/typechecker/infer/classes.rs b/crates/interpreter/src/typechecker/infer/classes.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/classes.rs rename to crates/interpreter/src/typechecker/infer/classes.rs diff --git a/crates/submilli-engine/src/typechecker/infer/closure_arity.rs b/crates/interpreter/src/typechecker/infer/closure_arity.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/closure_arity.rs rename to crates/interpreter/src/typechecker/infer/closure_arity.rs diff --git a/crates/submilli-engine/src/typechecker/infer/comparable.rs b/crates/interpreter/src/typechecker/infer/comparable.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/comparable.rs rename to crates/interpreter/src/typechecker/infer/comparable.rs diff --git a/crates/submilli-engine/src/typechecker/infer/comparison_operand.rs b/crates/interpreter/src/typechecker/infer/comparison_operand.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/comparison_operand.rs rename to crates/interpreter/src/typechecker/infer/comparison_operand.rs diff --git a/crates/submilli-engine/src/typechecker/infer/diagnostics.rs b/crates/interpreter/src/typechecker/infer/diagnostics.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/diagnostics.rs rename to crates/interpreter/src/typechecker/infer/diagnostics.rs diff --git a/crates/submilli-engine/src/typechecker/infer/enums.rs b/crates/interpreter/src/typechecker/infer/enums.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/enums.rs rename to crates/interpreter/src/typechecker/infer/enums.rs diff --git a/crates/submilli-engine/src/typechecker/infer/exports.rs b/crates/interpreter/src/typechecker/infer/exports.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/exports.rs rename to crates/interpreter/src/typechecker/infer/exports.rs diff --git a/crates/submilli-engine/src/typechecker/infer/expr.rs b/crates/interpreter/src/typechecker/infer/expr.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/expr.rs rename to crates/interpreter/src/typechecker/infer/expr.rs diff --git a/crates/submilli-engine/src/typechecker/infer/format_definition.rs b/crates/interpreter/src/typechecker/infer/format_definition.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/format_definition.rs rename to crates/interpreter/src/typechecker/infer/format_definition.rs diff --git a/crates/submilli-engine/src/typechecker/infer/format_signature.rs b/crates/interpreter/src/typechecker/infer/format_signature.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/format_signature.rs rename to crates/interpreter/src/typechecker/infer/format_signature.rs diff --git a/crates/submilli-engine/src/typechecker/infer/forward_globals.rs b/crates/interpreter/src/typechecker/infer/forward_globals.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/forward_globals.rs rename to crates/interpreter/src/typechecker/infer/forward_globals.rs diff --git a/crates/submilli-engine/src/typechecker/infer/generic.rs b/crates/interpreter/src/typechecker/infer/generic.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/generic.rs rename to crates/interpreter/src/typechecker/infer/generic.rs diff --git a/crates/submilli-engine/src/typechecker/infer/generic_scopes.rs b/crates/interpreter/src/typechecker/infer/generic_scopes.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/generic_scopes.rs rename to crates/interpreter/src/typechecker/infer/generic_scopes.rs diff --git a/crates/submilli-engine/src/typechecker/infer/globals.rs b/crates/interpreter/src/typechecker/infer/globals.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/globals.rs rename to crates/interpreter/src/typechecker/infer/globals.rs diff --git a/crates/submilli-engine/src/typechecker/infer/iife.rs b/crates/interpreter/src/typechecker/infer/iife.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/iife.rs rename to crates/interpreter/src/typechecker/infer/iife.rs diff --git a/crates/submilli-engine/src/typechecker/infer/import_graph.rs b/crates/interpreter/src/typechecker/infer/import_graph.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/import_graph.rs rename to crates/interpreter/src/typechecker/infer/import_graph.rs diff --git a/crates/submilli-engine/src/typechecker/infer/imports.rs b/crates/interpreter/src/typechecker/infer/imports.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/imports.rs rename to crates/interpreter/src/typechecker/infer/imports.rs diff --git a/crates/submilli-engine/src/typechecker/infer/inference_sources.rs b/crates/interpreter/src/typechecker/infer/inference_sources.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/inference_sources.rs rename to crates/interpreter/src/typechecker/infer/inference_sources.rs diff --git a/crates/submilli-engine/src/typechecker/infer/literal_freshness.rs b/crates/interpreter/src/typechecker/infer/literal_freshness.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/literal_freshness.rs rename to crates/interpreter/src/typechecker/infer/literal_freshness.rs diff --git a/crates/submilli-engine/src/typechecker/infer/lookup.rs b/crates/interpreter/src/typechecker/infer/lookup.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/lookup.rs rename to crates/interpreter/src/typechecker/infer/lookup.rs diff --git a/crates/submilli-engine/src/typechecker/infer/mod.rs b/crates/interpreter/src/typechecker/infer/mod.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/mod.rs rename to crates/interpreter/src/typechecker/infer/mod.rs diff --git a/crates/submilli-engine/src/typechecker/infer/module_symbols.rs b/crates/interpreter/src/typechecker/infer/module_symbols.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/module_symbols.rs rename to crates/interpreter/src/typechecker/infer/module_symbols.rs diff --git a/crates/submilli-engine/src/typechecker/infer/namespace_symbol.rs b/crates/interpreter/src/typechecker/infer/namespace_symbol.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/namespace_symbol.rs rename to crates/interpreter/src/typechecker/infer/namespace_symbol.rs diff --git a/crates/submilli-engine/src/typechecker/infer/narrow_scopes.rs b/crates/interpreter/src/typechecker/infer/narrow_scopes.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/narrow_scopes.rs rename to crates/interpreter/src/typechecker/infer/narrow_scopes.rs diff --git a/crates/submilli-engine/src/typechecker/infer/narrowing.rs b/crates/interpreter/src/typechecker/infer/narrowing.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/narrowing.rs rename to crates/interpreter/src/typechecker/infer/narrowing.rs diff --git a/crates/submilli-engine/src/typechecker/infer/nested_functions.rs b/crates/interpreter/src/typechecker/infer/nested_functions.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/nested_functions.rs rename to crates/interpreter/src/typechecker/infer/nested_functions.rs diff --git a/crates/submilli-engine/src/typechecker/infer/object_normalization.rs b/crates/interpreter/src/typechecker/infer/object_normalization.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/object_normalization.rs rename to crates/interpreter/src/typechecker/infer/object_normalization.rs diff --git a/crates/submilli-engine/src/typechecker/infer/param_defaults.rs b/crates/interpreter/src/typechecker/infer/param_defaults.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/param_defaults.rs rename to crates/interpreter/src/typechecker/infer/param_defaults.rs diff --git a/crates/submilli-engine/src/typechecker/infer/predicate_envs.rs b/crates/interpreter/src/typechecker/infer/predicate_envs.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/predicate_envs.rs rename to crates/interpreter/src/typechecker/infer/predicate_envs.rs diff --git a/crates/submilli-engine/src/typechecker/infer/records.rs b/crates/interpreter/src/typechecker/infer/records.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/records.rs rename to crates/interpreter/src/typechecker/infer/records.rs diff --git a/crates/submilli-engine/src/typechecker/infer/reserved.rs b/crates/interpreter/src/typechecker/infer/reserved.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/reserved.rs rename to crates/interpreter/src/typechecker/infer/reserved.rs diff --git a/crates/submilli-engine/src/typechecker/infer/resolve_type.rs b/crates/interpreter/src/typechecker/infer/resolve_type.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/resolve_type.rs rename to crates/interpreter/src/typechecker/infer/resolve_type.rs diff --git a/crates/submilli-engine/src/typechecker/infer/scopes.rs b/crates/interpreter/src/typechecker/infer/scopes.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/scopes.rs rename to crates/interpreter/src/typechecker/infer/scopes.rs diff --git a/crates/submilli-engine/src/typechecker/infer/shapes.rs b/crates/interpreter/src/typechecker/infer/shapes.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/shapes.rs rename to crates/interpreter/src/typechecker/infer/shapes.rs diff --git a/crates/submilli-engine/src/typechecker/infer/signatures.rs b/crates/interpreter/src/typechecker/infer/signatures.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/signatures.rs rename to crates/interpreter/src/typechecker/infer/signatures.rs diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap similarity index 99% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap index 62c2b905d..eb7c33cbe 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__expr__tests__snapshot_mixed_program.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/expr.rs +source: crates/interpreter/src/typechecker/infer/expr.rs assertion_line: 11231 expression: ta --- diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap similarity index 60% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap index bcd62830a..a4a703904 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__array_substitutes_interface_generic.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +source: crates/interpreter/src/typechecker/infer/format_definition.rs expression: out --- interface Array { diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap new file mode 100644 index 000000000..5ff731148 --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap @@ -0,0 +1,5 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +(arg0: number, arg1: string) => boolean diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap similarity index 53% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap index df4e0964b..d6ff091b3 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_ref_substitutes_multiple_args.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs +source: crates/interpreter/src/typechecker/infer/format_definition.rs expression: out --- interface Map { diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap new file mode 100644 index 000000000..8baeb041e --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap @@ -0,0 +1,7 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Box { + label?: string; +} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap new file mode 100644 index 000000000..3fe4c19c3 --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap @@ -0,0 +1,8 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Item { + key: number; + tag: string; +} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap new file mode 100644 index 000000000..3ae1b85ce --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap @@ -0,0 +1,7 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Cell { + value: number; +} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap new file mode 100644 index 000000000..c3bfa5ebf --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap @@ -0,0 +1,8 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +{ + name: string; + x: number; +} diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap new file mode 100644 index 000000000..3f7428f93 --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap @@ -0,0 +1,7 @@ +--- +source: crates/interpreter/src/typechecker/infer/format_definition.rs +expression: out +--- +interface Number { + toString(): string; +} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap similarity index 53% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap index d43c20a8b..ed2c2118b 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_arity_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- arity: expected at most 1 param(s), got 2 diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap similarity index 70% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap index e33f0b2b3..c36ad68ad 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_combined_arity_param_return.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- arity: expected at most 2 param(s), got 3 diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap similarity index 52% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap index 7cf47a6c8..b5bc1e8bc 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_param_type_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- param 2: expected `string`, got `number` diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap similarity index 52% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap index 10e8dd9fe..188385882 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__function_return_type_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- return: expected `number`, got `string` diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap similarity index 67% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap index 2327c2cb1..446efaf94 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_all_three_dimensions.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- missing field(s): `y` diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap new file mode 100644 index 000000000..18de567a2 --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap @@ -0,0 +1,5 @@ +--- +source: crates/interpreter/src/typechecker/infer/type_diff.rs +expression: out.unwrap() +--- +extra field(s): `y` diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap similarity index 59% rename from crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap rename to crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap index 54c77723d..a5364cc68 100644 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_field_type_mismatch.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs +source: crates/interpreter/src/typechecker/infer/type_diff.rs expression: out.unwrap() --- field type mismatches: diff --git a/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap new file mode 100644 index 000000000..8e602c22f --- /dev/null +++ b/crates/interpreter/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap @@ -0,0 +1,5 @@ +--- +source: crates/interpreter/src/typechecker/infer/type_diff.rs +expression: out.unwrap() +--- +missing field(s): `y` diff --git a/crates/submilli-engine/src/typechecker/infer/stmt.rs b/crates/interpreter/src/typechecker/infer/stmt.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/stmt.rs rename to crates/interpreter/src/typechecker/infer/stmt.rs diff --git a/crates/submilli-engine/src/typechecker/infer/switch_stmt.rs b/crates/interpreter/src/typechecker/infer/switch_stmt.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/switch_stmt.rs rename to crates/interpreter/src/typechecker/infer/switch_stmt.rs diff --git a/crates/submilli-engine/src/typechecker/infer/test_support.rs b/crates/interpreter/src/typechecker/infer/test_support.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/test_support.rs rename to crates/interpreter/src/typechecker/infer/test_support.rs diff --git a/crates/submilli-engine/src/typechecker/infer/type_aliases.rs b/crates/interpreter/src/typechecker/infer/type_aliases.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/type_aliases.rs rename to crates/interpreter/src/typechecker/infer/type_aliases.rs diff --git a/crates/submilli-engine/src/typechecker/infer/type_diff.rs b/crates/interpreter/src/typechecker/infer/type_diff.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/type_diff.rs rename to crates/interpreter/src/typechecker/infer/type_diff.rs diff --git a/crates/submilli-engine/src/typechecker/infer/type_namespace.rs b/crates/interpreter/src/typechecker/infer/type_namespace.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/type_namespace.rs rename to crates/interpreter/src/typechecker/infer/type_namespace.rs diff --git a/crates/submilli-engine/src/typechecker/infer/type_predicate.rs b/crates/interpreter/src/typechecker/infer/type_predicate.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/type_predicate.rs rename to crates/interpreter/src/typechecker/infer/type_predicate.rs diff --git a/crates/submilli-engine/src/typechecker/infer/type_registry.rs b/crates/interpreter/src/typechecker/infer/type_registry.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/type_registry.rs rename to crates/interpreter/src/typechecker/infer/type_registry.rs diff --git a/crates/submilli-engine/src/typechecker/infer/value_operand.rs b/crates/interpreter/src/typechecker/infer/value_operand.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/value_operand.rs rename to crates/interpreter/src/typechecker/infer/value_operand.rs diff --git a/crates/submilli-engine/src/typechecker/infer/variance.rs b/crates/interpreter/src/typechecker/infer/variance.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/infer/variance.rs rename to crates/interpreter/src/typechecker/infer/variance.rs diff --git a/crates/submilli-engine/src/typechecker/json_schema.rs b/crates/interpreter/src/typechecker/json_schema.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/json_schema.rs rename to crates/interpreter/src/typechecker/json_schema.rs diff --git a/crates/submilli-engine/src/typechecker/json_strategy.rs b/crates/interpreter/src/typechecker/json_strategy.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/json_strategy.rs rename to crates/interpreter/src/typechecker/json_strategy.rs diff --git a/crates/submilli-engine/src/typechecker/mod.rs b/crates/interpreter/src/typechecker/mod.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/mod.rs rename to crates/interpreter/src/typechecker/mod.rs diff --git a/crates/submilli-engine/src/typechecker/rules/body_walk.rs b/crates/interpreter/src/typechecker/rules/body_walk.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/body_walk.rs rename to crates/interpreter/src/typechecker/rules/body_walk.rs diff --git a/crates/submilli-engine/src/typechecker/rules/capability_consistency.rs b/crates/interpreter/src/typechecker/rules/capability_consistency.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/capability_consistency.rs rename to crates/interpreter/src/typechecker/rules/capability_consistency.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_calls.rs b/crates/interpreter/src/typechecker/rules/check_calls.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_calls.rs rename to crates/interpreter/src/typechecker/rules/check_calls.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/bodies.rs b/crates/interpreter/src/typechecker/rules/check_discipline/bodies.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/bodies.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/bodies.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/checked.rs b/crates/interpreter/src/typechecker/rules/check_discipline/checked.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/checked.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/checked.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/findings.rs b/crates/interpreter/src/typechecker/rules/check_discipline/findings.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/findings.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/findings.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/flow.rs b/crates/interpreter/src/typechecker/rules/check_discipline/flow.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/flow.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/flow.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/mod.rs b/crates/interpreter/src/typechecker/rules/check_discipline/mod.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/mod.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/mod.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/origin.rs b/crates/interpreter/src/typechecker/rules/check_discipline/origin.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/origin.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/origin.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/package.rs b/crates/interpreter/src/typechecker/rules/check_discipline/package.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/package.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/package.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/scope.rs b/crates/interpreter/src/typechecker/rules/check_discipline/scope.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/scope.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/scope.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/stability.rs b/crates/interpreter/src/typechecker/rules/check_discipline/stability.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/stability.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/stability.rs diff --git a/crates/submilli-engine/src/typechecker/rules/check_discipline/tests.rs b/crates/interpreter/src/typechecker/rules/check_discipline/tests.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/check_discipline/tests.rs rename to crates/interpreter/src/typechecker/rules/check_discipline/tests.rs diff --git a/crates/submilli-engine/src/typechecker/rules/control_flow.rs b/crates/interpreter/src/typechecker/rules/control_flow.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/control_flow.rs rename to crates/interpreter/src/typechecker/rules/control_flow.rs diff --git a/crates/submilli-engine/src/typechecker/rules/declarations.rs b/crates/interpreter/src/typechecker/rules/declarations.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/declarations.rs rename to crates/interpreter/src/typechecker/rules/declarations.rs diff --git a/crates/submilli-engine/src/typechecker/rules/definite_assignment.rs b/crates/interpreter/src/typechecker/rules/definite_assignment.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/definite_assignment.rs rename to crates/interpreter/src/typechecker/rules/definite_assignment.rs diff --git a/crates/submilli-engine/src/typechecker/rules/doc_consistency.rs b/crates/interpreter/src/typechecker/rules/doc_consistency.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/doc_consistency.rs rename to crates/interpreter/src/typechecker/rules/doc_consistency.rs diff --git a/crates/submilli-engine/src/typechecker/rules/exported_docs.rs b/crates/interpreter/src/typechecker/rules/exported_docs.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/exported_docs.rs rename to crates/interpreter/src/typechecker/rules/exported_docs.rs diff --git a/crates/submilli-engine/src/typechecker/rules/exported_signature_types.rs b/crates/interpreter/src/typechecker/rules/exported_signature_types.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/exported_signature_types.rs rename to crates/interpreter/src/typechecker/rules/exported_signature_types.rs diff --git a/crates/submilli-engine/src/typechecker/rules/fallthrough.rs b/crates/interpreter/src/typechecker/rules/fallthrough.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/fallthrough.rs rename to crates/interpreter/src/typechecker/rules/fallthrough.rs diff --git a/crates/submilli-engine/src/typechecker/rules/main_required.rs b/crates/interpreter/src/typechecker/rules/main_required.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/main_required.rs rename to crates/interpreter/src/typechecker/rules/main_required.rs diff --git a/crates/submilli-engine/src/typechecker/rules/missing_return.rs b/crates/interpreter/src/typechecker/rules/missing_return.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/missing_return.rs rename to crates/interpreter/src/typechecker/rules/missing_return.rs diff --git a/crates/submilli-engine/src/typechecker/rules/mod.rs b/crates/interpreter/src/typechecker/rules/mod.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/mod.rs rename to crates/interpreter/src/typechecker/rules/mod.rs diff --git a/crates/submilli-engine/src/typechecker/rules/return_outside_function.rs b/crates/interpreter/src/typechecker/rules/return_outside_function.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/return_outside_function.rs rename to crates/interpreter/src/typechecker/rules/return_outside_function.rs diff --git a/crates/submilli-engine/src/typechecker/rules/super_call.rs b/crates/interpreter/src/typechecker/rules/super_call.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/super_call.rs rename to crates/interpreter/src/typechecker/rules/super_call.rs diff --git a/crates/submilli-engine/src/typechecker/rules/unreachable.rs b/crates/interpreter/src/typechecker/rules/unreachable.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/rules/unreachable.rs rename to crates/interpreter/src/typechecker/rules/unreachable.rs diff --git a/crates/submilli-engine/src/typechecker/type_param_substitution.rs b/crates/interpreter/src/typechecker/type_param_substitution.rs similarity index 100% rename from crates/submilli-engine/src/typechecker/type_param_substitution.rs rename to crates/interpreter/src/typechecker/type_param_substitution.rs diff --git a/crates/submilli-engine/src/typed_ast.rs b/crates/interpreter/src/typed_ast.rs similarity index 100% rename from crates/submilli-engine/src/typed_ast.rs rename to crates/interpreter/src/typed_ast.rs diff --git a/crates/submilli-engine/src/types.rs b/crates/interpreter/src/types.rs similarity index 100% rename from crates/submilli-engine/src/types.rs rename to crates/interpreter/src/types.rs diff --git a/crates/submilli-engine/tests/checked_arena.rs b/crates/interpreter/tests/checked_arena.rs similarity index 100% rename from crates/submilli-engine/tests/checked_arena.rs rename to crates/interpreter/tests/checked_arena.rs diff --git a/crates/submilli-engine/tests/checked_rendering.rs b/crates/interpreter/tests/checked_rendering.rs similarity index 100% rename from crates/submilli-engine/tests/checked_rendering.rs rename to crates/interpreter/tests/checked_rendering.rs diff --git a/crates/submilli-engine/tests/checked_source.rs b/crates/interpreter/tests/checked_source.rs similarity index 100% rename from crates/submilli-engine/tests/checked_source.rs rename to crates/interpreter/tests/checked_source.rs diff --git a/crates/submilli-engine/tests/checked_typed_phases.rs b/crates/interpreter/tests/checked_typed_phases.rs similarity index 100% rename from crates/submilli-engine/tests/checked_typed_phases.rs rename to crates/interpreter/tests/checked_typed_phases.rs diff --git a/crates/submilli-engine/tests/checked_untyped_phases.rs b/crates/interpreter/tests/checked_untyped_phases.rs similarity index 100% rename from crates/submilli-engine/tests/checked_untyped_phases.rs rename to crates/interpreter/tests/checked_untyped_phases.rs diff --git a/crates/submilli-engine/tests/class_rec_group.rs b/crates/interpreter/tests/class_rec_group.rs similarity index 100% rename from crates/submilli-engine/tests/class_rec_group.rs rename to crates/interpreter/tests/class_rec_group.rs diff --git a/crates/submilli-engine/tests/closure_arity.rs b/crates/interpreter/tests/closure_arity.rs similarity index 100% rename from crates/submilli-engine/tests/closure_arity.rs rename to crates/interpreter/tests/closure_arity.rs diff --git a/crates/submilli-engine/tests/closure_arity_diagnostics.rs b/crates/interpreter/tests/closure_arity_diagnostics.rs similarity index 100% rename from crates/submilli-engine/tests/closure_arity_diagnostics.rs rename to crates/interpreter/tests/closure_arity_diagnostics.rs diff --git a/crates/submilli-engine/tests/closure_lowering_errors.rs b/crates/interpreter/tests/closure_lowering_errors.rs similarity index 100% rename from crates/submilli-engine/tests/closure_lowering_errors.rs rename to crates/interpreter/tests/closure_lowering_errors.rs diff --git a/crates/submilli-engine/tests/compiler_structure_limits.rs b/crates/interpreter/tests/compiler_structure_limits.rs similarity index 100% rename from crates/submilli-engine/tests/compiler_structure_limits.rs rename to crates/interpreter/tests/compiler_structure_limits.rs diff --git a/crates/submilli-engine/tests/console_failure.rs b/crates/interpreter/tests/console_failure.rs similarity index 100% rename from crates/submilli-engine/tests/console_failure.rs rename to crates/interpreter/tests/console_failure.rs diff --git a/crates/submilli-engine/tests/cross_module_gc_types.rs b/crates/interpreter/tests/cross_module_gc_types.rs similarity index 100% rename from crates/submilli-engine/tests/cross_module_gc_types.rs rename to crates/interpreter/tests/cross_module_gc_types.rs diff --git a/crates/submilli-engine/tests/decision_records.rs b/crates/interpreter/tests/decision_records.rs similarity index 100% rename from crates/submilli-engine/tests/decision_records.rs rename to crates/interpreter/tests/decision_records.rs diff --git a/crates/submilli-engine/tests/determinism.rs b/crates/interpreter/tests/determinism.rs similarity index 100% rename from crates/submilli-engine/tests/determinism.rs rename to crates/interpreter/tests/determinism.rs diff --git a/crates/submilli-engine/tests/diagnostic_snapshots.rs b/crates/interpreter/tests/diagnostic_snapshots.rs similarity index 100% rename from crates/submilli-engine/tests/diagnostic_snapshots.rs rename to crates/interpreter/tests/diagnostic_snapshots.rs diff --git a/crates/submilli-engine/tests/field_lookup_size.rs b/crates/interpreter/tests/field_lookup_size.rs similarity index 100% rename from crates/submilli-engine/tests/field_lookup_size.rs rename to crates/interpreter/tests/field_lookup_size.rs diff --git a/crates/submilli-engine/tests/fixtures.rs b/crates/interpreter/tests/fixtures.rs similarity index 100% rename from crates/submilli-engine/tests/fixtures.rs rename to crates/interpreter/tests/fixtures.rs diff --git a/crates/submilli-engine/tests/fixtures/alias_index_read_write.ts b/crates/interpreter/tests/fixtures/alias_index_read_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/alias_index_read_write.ts rename to crates/interpreter/tests/fixtures/alias_index_read_write.ts diff --git a/crates/submilli-engine/tests/fixtures/alias_peel_dispatch.ts b/crates/interpreter/tests/fixtures/alias_peel_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/alias_peel_dispatch.ts rename to crates/interpreter/tests/fixtures/alias_peel_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/angle_bracket_cast.ts b/crates/interpreter/tests/fixtures/angle_bracket_cast.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/angle_bracket_cast.ts rename to crates/interpreter/tests/fixtures/angle_bracket_cast.ts diff --git a/crates/submilli-engine/tests/fixtures/array_at.subm b/crates/interpreter/tests/fixtures/array_at.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_at.subm rename to crates/interpreter/tests/fixtures/array_at.subm diff --git a/crates/submilli-engine/tests/fixtures/array_callback_truthiness.ts b/crates/interpreter/tests/fixtures/array_callback_truthiness.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_callback_truthiness.ts rename to crates/interpreter/tests/fixtures/array_callback_truthiness.ts diff --git a/crates/submilli-engine/tests/fixtures/array_concat.subm b/crates/interpreter/tests/fixtures/array_concat.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_concat.subm rename to crates/interpreter/tests/fixtures/array_concat.subm diff --git a/crates/submilli-engine/tests/fixtures/array_copy_within.subm b/crates/interpreter/tests/fixtures/array_copy_within.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_copy_within.subm rename to crates/interpreter/tests/fixtures/array_copy_within.subm diff --git a/crates/submilli-engine/tests/fixtures/array_every.subm b/crates/interpreter/tests/fixtures/array_every.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_every.subm rename to crates/interpreter/tests/fixtures/array_every.subm diff --git a/crates/submilli-engine/tests/fixtures/array_fill.subm b/crates/interpreter/tests/fixtures/array_fill.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_fill.subm rename to crates/interpreter/tests/fixtures/array_fill.subm diff --git a/crates/submilli-engine/tests/fixtures/array_filter.subm b/crates/interpreter/tests/fixtures/array_filter.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_filter.subm rename to crates/interpreter/tests/fixtures/array_filter.subm diff --git a/crates/submilli-engine/tests/fixtures/array_filter_guard_narrows_to_class.ts b/crates/interpreter/tests/fixtures/array_filter_guard_narrows_to_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_filter_guard_narrows_to_class.ts rename to crates/interpreter/tests/fixtures/array_filter_guard_narrows_to_class.ts diff --git a/crates/submilli-engine/tests/fixtures/array_filter_type_guard_narrows.ts b/crates/interpreter/tests/fixtures/array_filter_type_guard_narrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_filter_type_guard_narrows.ts rename to crates/interpreter/tests/fixtures/array_filter_type_guard_narrows.ts diff --git a/crates/submilli-engine/tests/fixtures/array_find.subm b/crates/interpreter/tests/fixtures/array_find.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_find.subm rename to crates/interpreter/tests/fixtures/array_find.subm diff --git a/crates/submilli-engine/tests/fixtures/array_findindex.subm b/crates/interpreter/tests/fixtures/array_findindex.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_findindex.subm rename to crates/interpreter/tests/fixtures/array_findindex.subm diff --git a/crates/submilli-engine/tests/fixtures/array_flat.subm b/crates/interpreter/tests/fixtures/array_flat.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_flat.subm rename to crates/interpreter/tests/fixtures/array_flat.subm diff --git a/crates/submilli-engine/tests/fixtures/array_flat_depth_budget.ts b/crates/interpreter/tests/fixtures/array_flat_depth_budget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_flat_depth_budget.ts rename to crates/interpreter/tests/fixtures/array_flat_depth_budget.ts diff --git a/crates/submilli-engine/tests/fixtures/array_flat_depth_error.subm b/crates/interpreter/tests/fixtures/array_flat_depth_error.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_flat_depth_error.subm rename to crates/interpreter/tests/fixtures/array_flat_depth_error.subm diff --git a/crates/submilli-engine/tests/fixtures/array_flatmap.subm b/crates/interpreter/tests/fixtures/array_flatmap.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_flatmap.subm rename to crates/interpreter/tests/fixtures/array_flatmap.subm diff --git a/crates/submilli-engine/tests/fixtures/array_for_each.subm b/crates/interpreter/tests/fixtures/array_for_each.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_for_each.subm rename to crates/interpreter/tests/fixtures/array_for_each.subm diff --git a/crates/submilli-engine/tests/fixtures/array_from.subm b/crates/interpreter/tests/fixtures/array_from.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_from.subm rename to crates/interpreter/tests/fixtures/array_from.subm diff --git a/crates/submilli-engine/tests/fixtures/array_from_array_like_length.ts b/crates/interpreter/tests/fixtures/array_from_array_like_length.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_from_array_like_length.ts rename to crates/interpreter/tests/fixtures/array_from_array_like_length.ts diff --git a/crates/submilli-engine/tests/fixtures/array_from_array_like_wider_source.ts b/crates/interpreter/tests/fixtures/array_from_array_like_wider_source.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_from_array_like_wider_source.ts rename to crates/interpreter/tests/fixtures/array_from_array_like_wider_source.ts diff --git a/crates/submilli-engine/tests/fixtures/array_from_collections.ts b/crates/interpreter/tests/fixtures/array_from_collections.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_from_collections.ts rename to crates/interpreter/tests/fixtures/array_from_collections.ts diff --git a/crates/submilli-engine/tests/fixtures/array_generic_spelling.subm b/crates/interpreter/tests/fixtures/array_generic_spelling.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_generic_spelling.subm rename to crates/interpreter/tests/fixtures/array_generic_spelling.subm diff --git a/crates/submilli-engine/tests/fixtures/array_host_port_edges.ts b/crates/interpreter/tests/fixtures/array_host_port_edges.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_host_port_edges.ts rename to crates/interpreter/tests/fixtures/array_host_port_edges.ts diff --git a/crates/submilli-engine/tests/fixtures/array_includes.subm b/crates/interpreter/tests/fixtures/array_includes.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_includes.subm rename to crates/interpreter/tests/fixtures/array_includes.subm diff --git a/crates/submilli-engine/tests/fixtures/array_index_domain.ts b/crates/interpreter/tests/fixtures/array_index_domain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_index_domain.ts rename to crates/interpreter/tests/fixtures/array_index_domain.ts diff --git a/crates/submilli-engine/tests/fixtures/array_index_of.subm b/crates/interpreter/tests/fixtures/array_index_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_index_of.subm rename to crates/interpreter/tests/fixtures/array_index_of.subm diff --git a/crates/submilli-engine/tests/fixtures/array_index_oob_throws.subm b/crates/interpreter/tests/fixtures/array_index_oob_throws.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_index_oob_throws.subm rename to crates/interpreter/tests/fixtures/array_index_oob_throws.subm diff --git a/crates/submilli-engine/tests/fixtures/array_indexed_write_rhs_grows.ts b/crates/interpreter/tests/fixtures/array_indexed_write_rhs_grows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_indexed_write_rhs_grows.ts rename to crates/interpreter/tests/fixtures/array_indexed_write_rhs_grows.ts diff --git a/crates/submilli-engine/tests/fixtures/array_iter_next_result.ts b/crates/interpreter/tests/fixtures/array_iter_next_result.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_iter_next_result.ts rename to crates/interpreter/tests/fixtures/array_iter_next_result.ts diff --git a/crates/submilli-engine/tests/fixtures/array_join.subm b/crates/interpreter/tests/fixtures/array_join.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_join.subm rename to crates/interpreter/tests/fixtures/array_join.subm diff --git a/crates/submilli-engine/tests/fixtures/array_join_null.ts b/crates/interpreter/tests/fixtures/array_join_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_join_null.ts rename to crates/interpreter/tests/fixtures/array_join_null.ts diff --git a/crates/submilli-engine/tests/fixtures/array_keeps_regular_literal_types.ts b/crates/interpreter/tests/fixtures/array_keeps_regular_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_keeps_regular_literal_types.ts rename to crates/interpreter/tests/fixtures/array_keeps_regular_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/array_keys_values_entries.subm b/crates/interpreter/tests/fixtures/array_keys_values_entries.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_keys_values_entries.subm rename to crates/interpreter/tests/fixtures/array_keys_values_entries.subm diff --git a/crates/submilli-engine/tests/fixtures/array_last_index_of.subm b/crates/interpreter/tests/fixtures/array_last_index_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_last_index_of.subm rename to crates/interpreter/tests/fixtures/array_last_index_of.subm diff --git a/crates/submilli-engine/tests/fixtures/array_length.subm b/crates/interpreter/tests/fixtures/array_length.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_length.subm rename to crates/interpreter/tests/fixtures/array_length.subm diff --git a/crates/submilli-engine/tests/fixtures/array_like_union_reads.ts b/crates/interpreter/tests/fixtures/array_like_union_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_like_union_reads.ts rename to crates/interpreter/tests/fixtures/array_like_union_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/array_like_union_writes.ts b/crates/interpreter/tests/fixtures/array_like_union_writes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_like_union_writes.ts rename to crates/interpreter/tests/fixtures/array_like_union_writes.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_best_common_type.ts b/crates/interpreter/tests/fixtures/array_literal_best_common_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_best_common_type.ts rename to crates/interpreter/tests/fixtures/array_literal_best_common_type.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_element_order.ts b/crates/interpreter/tests/fixtures/array_literal_element_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_element_order.ts rename to crates/interpreter/tests/fixtures/array_literal_element_order.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_normalized_to_optional.ts b/crates/interpreter/tests/fixtures/array_literal_normalized_to_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_normalized_to_optional.ts rename to crates/interpreter/tests/fixtures/array_literal_normalized_to_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_object_normalization.ts b/crates/interpreter/tests/fixtures/array_literal_object_normalization.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_object_normalization.ts rename to crates/interpreter/tests/fixtures/array_literal_object_normalization.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_object_normalization_fresh_only.ts b/crates/interpreter/tests/fixtures/array_literal_object_normalization_fresh_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_object_normalization_fresh_only.ts rename to crates/interpreter/tests/fixtures/array_literal_object_normalization_fresh_only.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays.ts b/crates/interpreter/tests/fixtures/array_literal_union_of_arrays.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays.ts rename to crates/interpreter/tests/fixtures/array_literal_union_of_arrays.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays_mismatch.ts b/crates/interpreter/tests/fixtures/array_literal_union_of_arrays_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_union_of_arrays_mismatch.ts rename to crates/interpreter/tests/fixtures/array_literal_union_of_arrays_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_wider_element.ts b/crates/interpreter/tests/fixtures/array_literal_wider_element.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_wider_element.ts rename to crates/interpreter/tests/fixtures/array_literal_wider_element.ts diff --git a/crates/submilli-engine/tests/fixtures/array_literal_wider_element_mismatch.ts b/crates/interpreter/tests/fixtures/array_literal_wider_element_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_literal_wider_element_mismatch.ts rename to crates/interpreter/tests/fixtures/array_literal_wider_element_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/array_map.subm b/crates/interpreter/tests/fixtures/array_map.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_map.subm rename to crates/interpreter/tests/fixtures/array_map.subm diff --git a/crates/submilli-engine/tests/fixtures/array_of.subm b/crates/interpreter/tests/fixtures/array_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_of.subm rename to crates/interpreter/tests/fixtures/array_of.subm diff --git a/crates/submilli-engine/tests/fixtures/array_of_object_literal_arrays_union.ts b/crates/interpreter/tests/fixtures/array_of_object_literal_arrays_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_of_object_literal_arrays_union.ts rename to crates/interpreter/tests/fixtures/array_of_object_literal_arrays_union.ts diff --git a/crates/submilli-engine/tests/fixtures/array_pop.subm b/crates/interpreter/tests/fixtures/array_pop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_pop.subm rename to crates/interpreter/tests/fixtures/array_pop.subm diff --git a/crates/submilli-engine/tests/fixtures/array_push.subm b/crates/interpreter/tests/fixtures/array_push.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_push.subm rename to crates/interpreter/tests/fixtures/array_push.subm diff --git a/crates/submilli-engine/tests/fixtures/array_reduce.subm b/crates/interpreter/tests/fixtures/array_reduce.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_reduce.subm rename to crates/interpreter/tests/fixtures/array_reduce.subm diff --git a/crates/submilli-engine/tests/fixtures/array_reduce_right.subm b/crates/interpreter/tests/fixtures/array_reduce_right.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_reduce_right.subm rename to crates/interpreter/tests/fixtures/array_reduce_right.subm diff --git a/crates/submilli-engine/tests/fixtures/array_reverse.subm b/crates/interpreter/tests/fixtures/array_reverse.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_reverse.subm rename to crates/interpreter/tests/fixtures/array_reverse.subm diff --git a/crates/submilli-engine/tests/fixtures/array_shift_unshift.subm b/crates/interpreter/tests/fixtures/array_shift_unshift.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_shift_unshift.subm rename to crates/interpreter/tests/fixtures/array_shift_unshift.subm diff --git a/crates/submilli-engine/tests/fixtures/array_slice.subm b/crates/interpreter/tests/fixtures/array_slice.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_slice.subm rename to crates/interpreter/tests/fixtures/array_slice.subm diff --git a/crates/submilli-engine/tests/fixtures/array_some.subm b/crates/interpreter/tests/fixtures/array_some.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_some.subm rename to crates/interpreter/tests/fixtures/array_some.subm diff --git a/crates/submilli-engine/tests/fixtures/array_sort.subm b/crates/interpreter/tests/fixtures/array_sort.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_sort.subm rename to crates/interpreter/tests/fixtures/array_sort.subm diff --git a/crates/submilli-engine/tests/fixtures/array_sort_cached_units.ts b/crates/interpreter/tests/fixtures/array_sort_cached_units.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_sort_cached_units.ts rename to crates/interpreter/tests/fixtures/array_sort_cached_units.ts diff --git a/crates/submilli-engine/tests/fixtures/array_sort_keeps_comparator_pushes.ts b/crates/interpreter/tests/fixtures/array_sort_keeps_comparator_pushes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_sort_keeps_comparator_pushes.ts rename to crates/interpreter/tests/fixtures/array_sort_keeps_comparator_pushes.ts diff --git a/crates/submilli-engine/tests/fixtures/array_sort_stable_merge.ts b/crates/interpreter/tests/fixtures/array_sort_stable_merge.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_sort_stable_merge.ts rename to crates/interpreter/tests/fixtures/array_sort_stable_merge.ts diff --git a/crates/submilli-engine/tests/fixtures/array_splice.subm b/crates/interpreter/tests/fixtures/array_splice.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_splice.subm rename to crates/interpreter/tests/fixtures/array_splice.subm diff --git a/crates/submilli-engine/tests/fixtures/array_spread_parameter.ts b/crates/interpreter/tests/fixtures/array_spread_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_spread_parameter.ts rename to crates/interpreter/tests/fixtures/array_spread_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/array_to_reversed.subm b/crates/interpreter/tests/fixtures/array_to_reversed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_to_reversed.subm rename to crates/interpreter/tests/fixtures/array_to_reversed.subm diff --git a/crates/submilli-engine/tests/fixtures/array_to_sorted.subm b/crates/interpreter/tests/fixtures/array_to_sorted.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_to_sorted.subm rename to crates/interpreter/tests/fixtures/array_to_sorted.subm diff --git a/crates/submilli-engine/tests/fixtures/array_to_spliced.subm b/crates/interpreter/tests/fixtures/array_to_spliced.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_to_spliced.subm rename to crates/interpreter/tests/fixtures/array_to_spliced.subm diff --git a/crates/submilli-engine/tests/fixtures/array_values_host_iter.ts b/crates/interpreter/tests/fixtures/array_values_host_iter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_values_host_iter.ts rename to crates/interpreter/tests/fixtures/array_values_host_iter.ts diff --git a/crates/submilli-engine/tests/fixtures/array_with.subm b/crates/interpreter/tests/fixtures/array_with.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/array_with.subm rename to crates/interpreter/tests/fixtures/array_with.subm diff --git a/crates/submilli-engine/tests/fixtures/arrow_return_type_forms.ts b/crates/interpreter/tests/fixtures/arrow_return_type_forms.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/arrow_return_type_forms.ts rename to crates/interpreter/tests/fixtures/arrow_return_type_forms.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_allman_braces.ts b/crates/interpreter/tests/fixtures/asi_allman_braces.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_allman_braces.ts rename to crates/interpreter/tests/fixtures/asi_allman_braces.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_clause_and_arrow_wraps.ts b/crates/interpreter/tests/fixtures/asi_clause_and_arrow_wraps.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_clause_and_arrow_wraps.ts rename to crates/interpreter/tests/fixtures/asi_clause_and_arrow_wraps.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_keyword_members.ts b/crates/interpreter/tests/fixtures/asi_keyword_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_keyword_members.ts rename to crates/interpreter/tests/fixtures/asi_keyword_members.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_line_break_after_as_type.ts b/crates/interpreter/tests/fixtures/asi_line_break_after_as_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_line_break_after_as_type.ts rename to crates/interpreter/tests/fixtures/asi_line_break_after_as_type.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_line_wrapped_operators.subm b/crates/interpreter/tests/fixtures/asi_line_wrapped_operators.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_line_wrapped_operators.subm rename to crates/interpreter/tests/fixtures/asi_line_wrapped_operators.subm diff --git a/crates/submilli-engine/tests/fixtures/asi_statement_ends_at_closing_brace.ts b/crates/interpreter/tests/fixtures/asi_statement_ends_at_closing_brace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_statement_ends_at_closing_brace.ts rename to crates/interpreter/tests/fixtures/asi_statement_ends_at_closing_brace.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_template_substitution_wraps.ts b/crates/interpreter/tests/fixtures/asi_template_substitution_wraps.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_template_substitution_wraps.ts rename to crates/interpreter/tests/fixtures/asi_template_substitution_wraps.ts diff --git a/crates/submilli-engine/tests/fixtures/asi_type_members_in_brackets.ts b/crates/interpreter/tests/fixtures/asi_type_members_in_brackets.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/asi_type_members_in_brackets.ts rename to crates/interpreter/tests/fixtures/asi_type_members_in_brackets.ts diff --git a/crates/submilli-engine/tests/fixtures/assert_pass.subm b/crates/interpreter/tests/fixtures/assert_pass.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/assert_pass.subm rename to crates/interpreter/tests/fixtures/assert_pass.subm diff --git a/crates/submilli-engine/tests/fixtures/assert_throws_catchable.subm b/crates/interpreter/tests/fixtures/assert_throws_catchable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/assert_throws_catchable.subm rename to crates/interpreter/tests/fixtures/assert_throws_catchable.subm diff --git a/crates/submilli-engine/tests/fixtures/assignment_expression.ts b/crates/interpreter/tests/fixtures/assignment_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/assignment_expression.ts rename to crates/interpreter/tests/fixtures/assignment_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/assignment_keeps_literal_types.ts b/crates/interpreter/tests/fixtures/assignment_keeps_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/assignment_keeps_literal_types.ts rename to crates/interpreter/tests/fixtures/assignment_keeps_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/assignment_narrows_to_declared_member.ts b/crates/interpreter/tests/fixtures/assignment_narrows_to_declared_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/assignment_narrows_to_declared_member.ts rename to crates/interpreter/tests/fixtures/assignment_narrows_to_declared_member.ts diff --git a/crates/submilli-engine/tests/fixtures/bare_return_in_inferred_closure.ts b/crates/interpreter/tests/fixtures/bare_return_in_inferred_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bare_return_in_inferred_closure.ts rename to crates/interpreter/tests/fixtures/bare_return_in_inferred_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_arithmetic.subm b/crates/interpreter/tests/fixtures/bigint_arithmetic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_arithmetic.subm rename to crates/interpreter/tests/fixtures/bigint_arithmetic.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_compare.subm b/crates/interpreter/tests/fixtures/bigint_compare.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_compare.subm rename to crates/interpreter/tests/fixtures/bigint_compare.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_container_equality.subm b/crates/interpreter/tests/fixtures/bigint_container_equality.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_container_equality.subm rename to crates/interpreter/tests/fixtures/bigint_container_equality.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_conversions.subm b/crates/interpreter/tests/fixtures/bigint_conversions.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_conversions.subm rename to crates/interpreter/tests/fixtures/bigint_conversions.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_decimal_budget.ts b/crates/interpreter/tests/fixtures/bigint_decimal_budget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_decimal_budget.ts rename to crates/interpreter/tests/fixtures/bigint_decimal_budget.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_float_literal.subm b/crates/interpreter/tests/fixtures/bigint_float_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_float_literal.subm rename to crates/interpreter/tests/fixtures/bigint_float_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_join.subm b/crates/interpreter/tests/fixtures/bigint_join.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_join.subm rename to crates/interpreter/tests/fixtures/bigint_join.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_large_literal.subm b/crates/interpreter/tests/fixtures/bigint_large_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_large_literal.subm rename to crates/interpreter/tests/fixtures/bigint_large_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_literal_basic.subm b/crates/interpreter/tests/fixtures/bigint_literal_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_literal_basic.subm rename to crates/interpreter/tests/fixtures/bigint_literal_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_literal_narrowing.ts b/crates/interpreter/tests/fixtures/bigint_literal_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_literal_narrowing.ts rename to crates/interpreter/tests/fixtures/bigint_literal_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_literal_types.ts b/crates/interpreter/tests/fixtures/bigint_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_literal_types.ts rename to crates/interpreter/tests/fixtures/bigint_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_namespace_typo.subm b/crates/interpreter/tests/fixtures/bigint_namespace_typo.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_namespace_typo.subm rename to crates/interpreter/tests/fixtures/bigint_namespace_typo.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_number_exact.ts b/crates/interpreter/tests/fixtures/bigint_number_exact.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_number_exact.ts rename to crates/interpreter/tests/fixtures/bigint_number_exact.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_plus_number.subm b/crates/interpreter/tests/fixtures/bigint_plus_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_plus_number.subm rename to crates/interpreter/tests/fixtures/bigint_plus_number.subm diff --git a/crates/submilli-engine/tests/fixtures/bigint_to_json.ts b/crates/interpreter/tests/fixtures/bigint_to_json.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_to_json.ts rename to crates/interpreter/tests/fixtures/bigint_to_json.ts diff --git a/crates/submilli-engine/tests/fixtures/bigint_to_string_radix.subm b/crates/interpreter/tests/fixtures/bigint_to_string_radix.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/bigint_to_string_radix.subm rename to crates/interpreter/tests/fixtures/bigint_to_string_radix.subm diff --git a/crates/submilli-engine/tests/fixtures/bind_void_call_value.ts b/crates/interpreter/tests/fixtures/bind_void_call_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bind_void_call_value.ts rename to crates/interpreter/tests/fixtures/bind_void_call_value.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/calls.ts b/crates/interpreter/tests/fixtures/binding_scope/calls.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/calls.ts rename to crates/interpreter/tests/fixtures/binding_scope/calls.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/capture_block_shadow.ts b/crates/interpreter/tests/fixtures/binding_scope/capture_block_shadow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/capture_block_shadow.ts rename to crates/interpreter/tests/fixtures/binding_scope/capture_block_shadow.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/captured_write.ts b/crates/interpreter/tests/fixtures/binding_scope/captured_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/captured_write.ts rename to crates/interpreter/tests/fixtures/binding_scope/captured_write.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/early_assignment.ts b/crates/interpreter/tests/fixtures/binding_scope/early_assignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/early_assignment.ts rename to crates/interpreter/tests/fixtures/binding_scope/early_assignment.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/early_namespace.ts b/crates/interpreter/tests/fixtures/binding_scope/early_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/early_namespace.ts rename to crates/interpreter/tests/fixtures/binding_scope/early_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_shadow.ts b/crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_shadow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_shadow.ts rename to crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_shadow.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_tdz.ts b/crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/for_of_pattern_tdz.ts rename to crates/interpreter/tests/fixtures/binding_scope/for_of_pattern_tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/for_of_tdz.ts b/crates/interpreter/tests/fixtures/binding_scope/for_of_tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/for_of_tdz.ts rename to crates/interpreter/tests/fixtures/binding_scope/for_of_tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/hygiene.ts b/crates/interpreter/tests/fixtures/binding_scope/hygiene.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/hygiene.ts rename to crates/interpreter/tests/fixtures/binding_scope/hygiene.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/hygiene_array.ts b/crates/interpreter/tests/fixtures/binding_scope/hygiene_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/hygiene_array.ts rename to crates/interpreter/tests/fixtures/binding_scope/hygiene_array.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/hygiene_iterator.ts b/crates/interpreter/tests/fixtures/binding_scope/hygiene_iterator.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/hygiene_iterator.ts rename to crates/interpreter/tests/fixtures/binding_scope/hygiene_iterator.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/intrinsic.ts b/crates/interpreter/tests/fixtures/binding_scope/intrinsic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/intrinsic.ts rename to crates/interpreter/tests/fixtures/binding_scope/intrinsic.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/mutators.ts b/crates/interpreter/tests/fixtures/binding_scope/mutators.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/mutators.ts rename to crates/interpreter/tests/fixtures/binding_scope/mutators.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/namespace.ts b/crates/interpreter/tests/fixtures/binding_scope/namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/namespace.ts rename to crates/interpreter/tests/fixtures/binding_scope/namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/parseint_required_arg.ts b/crates/interpreter/tests/fixtures/binding_scope/parseint_required_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/parseint_required_arg.ts rename to crates/interpreter/tests/fixtures/binding_scope/parseint_required_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/pattern_hygiene.ts b/crates/interpreter/tests/fixtures/binding_scope/pattern_hygiene.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/pattern_hygiene.ts rename to crates/interpreter/tests/fixtures/binding_scope/pattern_hygiene.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_catch.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare_catch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare_catch.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare_catch.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_let.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare_let.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare_let.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare_let.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_param.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare_param.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare_param.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare_param.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_pattern.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare_pattern.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare_pattern.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare_pattern.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/redeclare_rest.ts b/crates/interpreter/tests/fixtures/binding_scope/redeclare_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/redeclare_rest.ts rename to crates/interpreter/tests/fixtures/binding_scope/redeclare_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/self_initialization.ts b/crates/interpreter/tests/fixtures/binding_scope/self_initialization.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/self_initialization.ts rename to crates/interpreter/tests/fixtures/binding_scope/self_initialization.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/shadowing.ts b/crates/interpreter/tests/fixtures/binding_scope/shadowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/shadowing.ts rename to crates/interpreter/tests/fixtures/binding_scope/shadowing.ts diff --git a/crates/submilli-engine/tests/fixtures/binding_scope/tdz.ts b/crates/interpreter/tests/fixtures/binding_scope/tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/binding_scope/tdz.ts rename to crates/interpreter/tests/fixtures/binding_scope/tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/asi.ts b/crates/interpreter/tests/fixtures/bitwise/asi.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/asi.ts rename to crates/interpreter/tests/fixtures/bitwise/asi.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/assignments.ts b/crates/interpreter/tests/fixtures/bitwise/assignments.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/assignments.ts rename to crates/interpreter/tests/fixtures/bitwise/assignments.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/bigints.ts b/crates/interpreter/tests/fixtures/bitwise/bigints.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/bigints.ts rename to crates/interpreter/tests/fixtures/bitwise/bigints.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/coercion.ts b/crates/interpreter/tests/fixtures/bitwise/coercion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/coercion.ts rename to crates/interpreter/tests/fixtures/bitwise/coercion.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/evaluation.ts b/crates/interpreter/tests/fixtures/bitwise/evaluation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/evaluation.ts rename to crates/interpreter/tests/fixtures/bitwise/evaluation.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/generics.ts b/crates/interpreter/tests/fixtures/bitwise/generics.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/generics.ts rename to crates/interpreter/tests/fixtures/bitwise/generics.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/invalid.ts b/crates/interpreter/tests/fixtures/bitwise/invalid.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/invalid.ts rename to crates/interpreter/tests/fixtures/bitwise/invalid.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/invalid_unary.ts b/crates/interpreter/tests/fixtures/bitwise/invalid_unary.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/invalid_unary.ts rename to crates/interpreter/tests/fixtures/bitwise/invalid_unary.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/live_values.ts b/crates/interpreter/tests/fixtures/bitwise/live_values.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/live_values.ts rename to crates/interpreter/tests/fixtures/bitwise/live_values.ts diff --git a/crates/submilli-engine/tests/fixtures/bitwise/numbers.ts b/crates/interpreter/tests/fixtures/bitwise/numbers.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bitwise/numbers.ts rename to crates/interpreter/tests/fixtures/bitwise/numbers.ts diff --git a/crates/submilli-engine/tests/fixtures/boolean_literal_types.ts b/crates/interpreter/tests/fixtures/boolean_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/boolean_literal_types.ts rename to crates/interpreter/tests/fixtures/boolean_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/boxed_primitive_vtables.ts b/crates/interpreter/tests/fixtures/boxed_primitive_vtables.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/boxed_primitive_vtables.ts rename to crates/interpreter/tests/fixtures/boxed_primitive_vtables.ts diff --git a/crates/submilli-engine/tests/fixtures/braceless_bodies_accepted.ts b/crates/interpreter/tests/fixtures/braceless_bodies_accepted.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/braceless_bodies_accepted.ts rename to crates/interpreter/tests/fixtures/braceless_bodies_accepted.ts diff --git a/crates/submilli-engine/tests/fixtures/braceless_control_bodies.subm b/crates/interpreter/tests/fixtures/braceless_control_bodies.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/braceless_control_bodies.subm rename to crates/interpreter/tests/fixtures/braceless_control_bodies.subm diff --git a/crates/submilli-engine/tests/fixtures/builtin_error.subm b/crates/interpreter/tests/fixtures/builtin_error.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/builtin_error.subm rename to crates/interpreter/tests/fixtures/builtin_error.subm diff --git a/crates/submilli-engine/tests/fixtures/bulk_string_and_byte_copies.ts b/crates/interpreter/tests/fixtures/bulk_string_and_byte_copies.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/bulk_string_and_byte_copies.ts rename to crates/interpreter/tests/fixtures/bulk_string_and_byte_copies.ts diff --git a/crates/submilli-engine/tests/fixtures/call_sig_number_from_string.subm b/crates/interpreter/tests/fixtures/call_sig_number_from_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/call_sig_number_from_string.subm rename to crates/interpreter/tests/fixtures/call_sig_number_from_string.subm diff --git a/crates/submilli-engine/tests/fixtures/call_sig_string_coercion.subm b/crates/interpreter/tests/fixtures/call_sig_string_coercion.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/call_sig_string_coercion.subm rename to crates/interpreter/tests/fixtures/call_sig_string_coercion.subm diff --git a/crates/submilli-engine/tests/fixtures/call_sig_user_interface.subm b/crates/interpreter/tests/fixtures/call_sig_user_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/call_sig_user_interface.subm rename to crates/interpreter/tests/fixtures/call_sig_user_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/captured_let_same_frame_reassign.subm b/crates/interpreter/tests/fixtures/captured_let_same_frame_reassign.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/captured_let_same_frame_reassign.subm rename to crates/interpreter/tests/fixtures/captured_let_same_frame_reassign.subm diff --git a/crates/submilli-engine/tests/fixtures/cast_and_spread_object_literals.ts b/crates/interpreter/tests/fixtures/cast_and_spread_object_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cast_and_spread_object_literals.ts rename to crates/interpreter/tests/fixtures/cast_and_spread_object_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/cast_rest_function_to_fixed_arity.ts b/crates/interpreter/tests/fixtures/cast_rest_function_to_fixed_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cast_rest_function_to_fixed_arity.ts rename to crates/interpreter/tests/fixtures/cast_rest_function_to_fixed_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/cast_self_nominal_interface.ts b/crates/interpreter/tests/fixtures/cast_self_nominal_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cast_self_nominal_interface.ts rename to crates/interpreter/tests/fixtures/cast_self_nominal_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/cast_to_union_member_overlap.ts b/crates/interpreter/tests/fixtures/cast_to_union_member_overlap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cast_to_union_member_overlap.ts rename to crates/interpreter/tests/fixtures/cast_to_union_member_overlap.ts diff --git a/crates/submilli-engine/tests/fixtures/cast_void_adapter_to_value_function.ts b/crates/interpreter/tests/fixtures/cast_void_adapter_to_value_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cast_void_adapter_to_value_function.ts rename to crates/interpreter/tests/fixtures/cast_void_adapter_to_value_function.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/as_array_element_check.subm b/crates/interpreter/tests/fixtures/casts/as_array_element_check.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_array_element_check.subm rename to crates/interpreter/tests/fixtures/casts/as_array_element_check.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_chain_round_trip.subm b/crates/interpreter/tests/fixtures/casts/as_chain_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_chain_round_trip.subm rename to crates/interpreter/tests/fixtures/casts/as_chain_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_enum_target.ts b/crates/interpreter/tests/fixtures/casts/as_enum_target.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_enum_target.ts rename to crates/interpreter/tests/fixtures/casts/as_enum_target.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/as_interface_non_object_throws.subm b/crates/interpreter/tests/fixtures/casts/as_interface_non_object_throws.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_interface_non_object_throws.subm rename to crates/interpreter/tests/fixtures/casts/as_interface_non_object_throws.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_nested_and_optional.subm b/crates/interpreter/tests/fixtures/casts/as_nested_and_optional.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_nested_and_optional.subm rename to crates/interpreter/tests/fixtures/casts/as_nested_and_optional.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_number_passthrough.subm b/crates/interpreter/tests/fixtures/casts/as_number_passthrough.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_number_passthrough.subm rename to crates/interpreter/tests/fixtures/casts/as_number_passthrough.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_object_literal_field.subm b/crates/interpreter/tests/fixtures/casts/as_object_literal_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_object_literal_field.subm rename to crates/interpreter/tests/fixtures/casts/as_object_literal_field.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_proven_upcast_no_check.subm b/crates/interpreter/tests/fixtures/casts/as_proven_upcast_no_check.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_proven_upcast_no_check.subm rename to crates/interpreter/tests/fixtures/casts/as_proven_upcast_no_check.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_recursive_object.subm b/crates/interpreter/tests/fixtures/casts/as_recursive_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_recursive_object.subm rename to crates/interpreter/tests/fixtures/casts/as_recursive_object.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_recursive_union.subm b/crates/interpreter/tests/fixtures/casts/as_recursive_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_recursive_union.subm rename to crates/interpreter/tests/fixtures/casts/as_recursive_union.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_string_passthrough.subm b/crates/interpreter/tests/fixtures/casts/as_string_passthrough.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_string_passthrough.subm rename to crates/interpreter/tests/fixtures/casts/as_string_passthrough.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_union_to_member.subm b/crates/interpreter/tests/fixtures/casts/as_union_to_member.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_union_to_member.subm rename to crates/interpreter/tests/fixtures/casts/as_union_to_member.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_unknown_to_interface.subm b/crates/interpreter/tests/fixtures/casts/as_unknown_to_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_unknown_to_interface.subm rename to crates/interpreter/tests/fixtures/casts/as_unknown_to_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/as_unknown_to_object_shape.subm b/crates/interpreter/tests/fixtures/casts/as_unknown_to_object_shape.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/as_unknown_to_object_shape.subm rename to crates/interpreter/tests/fixtures/casts/as_unknown_to_object_shape.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/expect_error_incompatible_static_cast.subm b/crates/interpreter/tests/fixtures/casts/expect_error_incompatible_static_cast.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/expect_error_incompatible_static_cast.subm rename to crates/interpreter/tests/fixtures/casts/expect_error_incompatible_static_cast.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm b/crates/interpreter/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm rename to crates/interpreter/tests/fixtures/casts/expect_error_object_to_unrelated_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/casts/issue_905_paths.ts b/crates/interpreter/tests/fixtures/casts/issue_905_paths.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/issue_905_paths.ts rename to crates/interpreter/tests/fixtures/casts/issue_905_paths.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/issue_982_disjoint.ts b/crates/interpreter/tests/fixtures/casts/issue_982_disjoint.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/issue_982_disjoint.ts rename to crates/interpreter/tests/fixtures/casts/issue_982_disjoint.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/issue_982_literal_overlap.ts b/crates/interpreter/tests/fixtures/casts/issue_982_literal_overlap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/issue_982_literal_overlap.ts rename to crates/interpreter/tests/fixtures/casts/issue_982_literal_overlap.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/uint8array_is_as.ts b/crates/interpreter/tests/fixtures/casts/uint8array_is_as.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/uint8array_is_as.ts rename to crates/interpreter/tests/fixtures/casts/uint8array_is_as.ts diff --git a/crates/submilli-engine/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm b/crates/interpreter/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm rename to crates/interpreter/tests/fixtures/casts/unknown_to_number_throws_and_catches.subm diff --git a/crates/submilli-engine/tests/fixtures/chain_generic_method_reference.ts b/crates/interpreter/tests/fixtures/chain_generic_method_reference.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/chain_generic_method_reference.ts rename to crates/interpreter/tests/fixtures/chain_generic_method_reference.ts diff --git a/crates/submilli-engine/tests/fixtures/chain_non_generic_optional_calls.ts b/crates/interpreter/tests/fixtures/chain_non_generic_optional_calls.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/chain_non_generic_optional_calls.ts rename to crates/interpreter/tests/fixtures/chain_non_generic_optional_calls.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_destructure/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_destructure/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_destructure/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_destructure/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_destructured_param/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_destructured_param/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_destructured_param/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_destructured_param/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_exported_arrow/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_for_of/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_for_of/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_for_of/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_for_of/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_narrowed_root/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_package_value/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_package_value/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_package_value/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_package_value/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_primitives/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_primitives/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_primitives/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_primitives/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_response_mapping/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_response_mapping/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_response_mapping/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_response_mapping/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_sibling_of_checked/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_unchecked_payload/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/clean_unguarded/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/clean_unguarded/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/clean_unguarded/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/clean_unguarded/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_argument/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_argument/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_argument/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_argument/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_array_literal/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_array_literal/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_array_literal/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_array_literal/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_callback/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_callback/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_callback/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_callback/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_captured/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_captured/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_captured/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_captured/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_checked_ancestor/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_context/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_context/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_context/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_context/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_merged/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_merged/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_merged/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_merged/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_method_call/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_method_call/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_method_call/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_method_call/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_mutation/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_mutation/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_mutation/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_mutation/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_operand/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_operand/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_operand/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_operand/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_returned/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_returned/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_returned/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_returned/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_spread/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_spread/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_spread/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_spread/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_stored/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_stored/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_stored/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_stored/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/escape_thrown/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/escape_thrown/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/escape_thrown/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/escape_thrown/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_closure/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_closure/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_closure/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_closure/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_conditional_arrows/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/internal.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/internal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/internal.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/internal.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_internal_module/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_internal_module/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_members/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_members/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_members/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_members/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_module_level/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_module_level/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_module_level/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_module_level/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_private_helper/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_private_helper/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_private_helper/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_private_helper/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/internal.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_reexport/internal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/internal.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_reexport/internal.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_reexport/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_reexport/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_reexport/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/placement_unexported_arrow/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_iteration/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_iteration/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_iteration/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_iteration/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_alias/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_alias/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_alias/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_alias/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_cast_arrow/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_control/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_control/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_control/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_control/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_early_exit/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_exported_arrow/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_loop/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_loop/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_loop/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_loop/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_module_variable/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_narrowed/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts b/crates/interpreter/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts rename to crates/interpreter/tests/fixtures/check_discipline/repeated_read_through_helper/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/class_chain_at_limit.ts b/crates/interpreter/tests/fixtures/class_chain_at_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/class_chain_at_limit.ts rename to crates/interpreter/tests/fixtures/class_chain_at_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/class_never_field_collection_key.ts b/crates/interpreter/tests/fixtures/class_never_field_collection_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/class_never_field_collection_key.ts rename to crates/interpreter/tests/fixtures/class_never_field_collection_key.ts diff --git a/crates/submilli-engine/tests/fixtures/class_to_string_field.ts b/crates/interpreter/tests/fixtures/class_to_string_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/class_to_string_field.ts rename to crates/interpreter/tests/fixtures/class_to_string_field.ts diff --git a/crates/submilli-engine/tests/fixtures/class_used_before_declaration_throws.ts b/crates/interpreter/tests/fixtures/class_used_before_declaration_throws.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/class_used_before_declaration_throws.ts rename to crates/interpreter/tests/fixtures/class_used_before_declaration_throws.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/abstract_member.ts b/crates/interpreter/tests/fixtures/classes/abstract_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/abstract_member.ts rename to crates/interpreter/tests/fixtures/classes/abstract_member.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts b/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts rename to crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest b/crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest rename to crates/interpreter/tests/fixtures/classes/accessor_across_package_boundary/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_basic.ts b/crates/interpreter/tests/fixtures/classes/accessor_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_basic.ts rename to crates/interpreter/tests/fixtures/classes/accessor_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/accessor_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/accessor_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/geo/lib.ts b/crates/interpreter/tests/fixtures/classes/accessor_cross_package/geo/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/geo/lib.ts rename to crates/interpreter/tests/fixtures/classes/accessor_cross_package/geo/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/accessor_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/accessor_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_different_types.ts b/crates/interpreter/tests/fixtures/classes/accessor_different_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_different_types.ts rename to crates/interpreter/tests/fixtures/classes/accessor_different_types.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_half_inherited.ts b/crates/interpreter/tests/fixtures/classes/accessor_half_inherited.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_half_inherited.ts rename to crates/interpreter/tests/fixtures/classes/accessor_half_inherited.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_implements_readonly.ts b/crates/interpreter/tests/fixtures/classes/accessor_implements_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_implements_readonly.ts rename to crates/interpreter/tests/fixtures/classes/accessor_implements_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts b/crates/interpreter/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts rename to crates/interpreter/tests/fixtures/classes/accessor_name_is_not_proof_of_an_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_override.ts b/crates/interpreter/tests/fixtures/classes/accessor_override.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_override.ts rename to crates/interpreter/tests/fixtures/classes/accessor_override.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_readonly.ts b/crates/interpreter/tests/fixtures/classes/accessor_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_readonly.ts rename to crates/interpreter/tests/fixtures/classes/accessor_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_redeclared_compatibly.ts b/crates/interpreter/tests/fixtures/classes/accessor_redeclared_compatibly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_redeclared_compatibly.ts rename to crates/interpreter/tests/fixtures/classes/accessor_redeclared_compatibly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_via_interface.ts b/crates/interpreter/tests/fixtures/classes/accessor_via_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_via_interface.ts rename to crates/interpreter/tests/fixtures/classes/accessor_via_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/accessor_write_only.ts b/crates/interpreter/tests/fixtures/classes/accessor_write_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/accessor_write_only.ts rename to crates/interpreter/tests/fixtures/classes/accessor_write_only.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/bad_override.ts b/crates/interpreter/tests/fixtures/classes/bad_override.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/bad_override.ts rename to crates/interpreter/tests/fixtures/classes/bad_override.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/captured_class_binding_boxed.ts b/crates/interpreter/tests/fixtures/classes/captured_class_binding_boxed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/captured_class_binding_boxed.ts rename to crates/interpreter/tests/fixtures/classes/captured_class_binding_boxed.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/cast_accessor_conformance.ts b/crates/interpreter/tests/fixtures/classes/cast_accessor_conformance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/cast_accessor_conformance.ts rename to crates/interpreter/tests/fixtures/classes/cast_accessor_conformance.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts b/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts rename to crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/geo/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/cast_accessor_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/catch_generic_error_bare.ts b/crates/interpreter/tests/fixtures/classes/catch_generic_error_bare.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/catch_generic_error_bare.ts rename to crates/interpreter/tests/fixtures/classes/catch_generic_error_bare.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/closure_captures_this.ts b/crates/interpreter/tests/fixtures/classes/closure_captures_this.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/closure_captures_this.ts rename to crates/interpreter/tests/fixtures/classes/closure_captures_this.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/closure_in_member_bodies.ts b/crates/interpreter/tests/fixtures/classes/closure_in_member_bodies.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/closure_in_member_bodies.ts rename to crates/interpreter/tests/fixtures/classes/closure_in_member_bodies.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts b/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts rename to crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/counters/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts b/crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts rename to crates/interpreter/tests/fixtures/classes/compound_assign_cross_package/tickers/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_field.ts b/crates/interpreter/tests/fixtures/classes/compound_assign_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_field.ts rename to crates/interpreter/tests/fixtures/classes/compound_assign_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/compound_assign_generic_field.ts b/crates/interpreter/tests/fixtures/classes/compound_assign_generic_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/compound_assign_generic_field.ts rename to crates/interpreter/tests/fixtures/classes/compound_assign_generic_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/construct_and_read_fields.ts b/crates/interpreter/tests/fixtures/classes/construct_and_read_fields.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/construct_and_read_fields.ts rename to crates/interpreter/tests/fixtures/classes/construct_and_read_fields.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/ctor_class_param_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_default_and_rest.ts b/crates/interpreter/tests/fixtures/classes/ctor_default_and_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_default_and_rest.ts rename to crates/interpreter/tests/fixtures/classes/ctor_default_and_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/ctor_default_rest_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts b/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts rename to crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest b/crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest rename to crates/interpreter/tests/fixtures/classes/dispatched_defaults_packages/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/dynamic_dispatch.ts b/crates/interpreter/tests/fixtures/classes/dynamic_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/dynamic_dispatch.ts rename to crates/interpreter/tests/fixtures/classes/dynamic_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/equals_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/equals_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/labeled/lib.ts b/crates/interpreter/tests/fixtures/classes/equals_cross_package/labeled/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_cross_package/labeled/lib.ts rename to crates/interpreter/tests/fixtures/classes/equals_cross_package/labeled/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/equals_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/equals_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_cross_package/points/lib.ts b/crates/interpreter/tests/fixtures/classes/equals_cross_package/points/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_cross_package/points/lib.ts rename to crates/interpreter/tests/fixtures/classes/equals_cross_package/points/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_error.ts b/crates/interpreter/tests/fixtures/classes/equals_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_error.ts rename to crates/interpreter/tests/fixtures/classes/equals_error.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_nullable_field.ts b/crates/interpreter/tests/fixtures/classes/equals_nullable_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_nullable_field.ts rename to crates/interpreter/tests/fixtures/classes/equals_nullable_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_sibling_same_shape.ts b/crates/interpreter/tests/fixtures/classes/equals_sibling_same_shape.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_sibling_same_shape.ts rename to crates/interpreter/tests/fixtures/classes/equals_sibling_same_shape.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_structural_fields.ts b/crates/interpreter/tests/fixtures/classes/equals_structural_fields.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_structural_fields.ts rename to crates/interpreter/tests/fixtures/classes/equals_structural_fields.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_subclass_vs_base.ts b/crates/interpreter/tests/fixtures/classes/equals_subclass_vs_base.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_subclass_vs_base.ts rename to crates/interpreter/tests/fixtures/classes/equals_subclass_vs_base.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/equals_vs_other_runtime_types.ts b/crates/interpreter/tests/fixtures/classes/equals_vs_other_runtime_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/equals_vs_other_runtime_types.ts rename to crates/interpreter/tests/fixtures/classes/equals_vs_other_runtime_types.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_catch_closure_capture.ts b/crates/interpreter/tests/fixtures/classes/error_catch_closure_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_catch_closure_capture.ts rename to crates/interpreter/tests/fixtures/classes/error_catch_closure_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_field_mutation.ts b/crates/interpreter/tests/fixtures/classes/error_field_mutation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_field_mutation.ts rename to crates/interpreter/tests/fixtures/classes/error_field_mutation.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_basic.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_basic.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/errs/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/error_subclass_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_throw_catch.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_throw_catch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_throw_catch.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_throw_catch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch_finally.ts b/crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch_finally.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_subclass_typed_catch_finally.ts rename to crates/interpreter/tests/fixtures/classes/error_subclass_typed_catch_finally.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/error_union_null.ts b/crates/interpreter/tests/fixtures/classes/error_union_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/error_union_null.ts rename to crates/interpreter/tests/fixtures/classes/error_union_null.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_half_guards.ts b/crates/interpreter/tests/fixtures/classes/expect_error_accessor_half_guards.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_half_guards.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_accessor_half_guards.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts b/crates/interpreter/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_accessor_redeclared_incompatibly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts b/crates/interpreter/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_accessor_type_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_missing_static.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_missing_static.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_missing_static.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_missing_static.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/counters/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_readonly_static/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/counters/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_private_static/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/counters/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_readonly_static_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_method.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_method.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_static_method.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_readonly.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_readonly.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_static_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_static_wrong_type.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_assign_to_method.ts b/crates/interpreter/tests/fixtures/classes/expect_error_assign_to_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_assign_to_method.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_assign_to_method.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_bare_class_value.ts b/crates/interpreter/tests/fixtures/classes/expect_error_bare_class_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_bare_class_value.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_bare_class_value.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_generic_args.ts b/crates/interpreter/tests/fixtures/classes/expect_error_catch_generic_args.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_catch_generic_args.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_catch_generic_args.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_non_error.ts b/crates/interpreter/tests/fixtures/classes/expect_error_catch_non_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_catch_non_error.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_catch_non_error.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_catch_unrelated_class.ts b/crates/interpreter/tests/fixtures/classes/expect_error_catch_unrelated_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_catch_unrelated_class.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_catch_unrelated_class.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_compound_assign_readonly.ts b/crates/interpreter/tests/fixtures/classes/expect_error_compound_assign_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_compound_assign_readonly.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_compound_assign_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts b/crates/interpreter/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_ctor_arity_default_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts b/crates/interpreter/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_deep_chain_shape_dump.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts b/crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_visibility.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_wider.ts b/crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_wider.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_field_redeclared_wider.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_field_redeclared_wider.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_field_used_before_initialization.ts b/crates/interpreter/tests/fixtures/classes/expect_error_field_used_before_initialization.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_field_used_before_initialization.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_field_used_before_initialization.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts b/crates/interpreter/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_generic_chain_shape_dump.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts b/crates/interpreter/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_getter_only_vs_settable.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_interface.ts b/crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_interface.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts b/crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_implements_aliased_non_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_missing_member.ts b/crates/interpreter/tests/fixtures/classes/expect_error_implements_missing_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_implements_missing_member.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_implements_missing_member.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_arity.ts b/crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_arity.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_signature.ts b/crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_implements_wrong_signature.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_implements_wrong_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_instance_on_class.ts b/crates/interpreter/tests/fixtures/classes/expect_error_instance_on_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_instance_on_class.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_instance_on_class.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_interface.ts b/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_interface.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_instanceof_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts b/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_instanceof_uint8array_unrelated.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_unrelated.ts b/crates/interpreter/tests/fixtures/classes/expect_error_instanceof_unrelated.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_instanceof_unrelated.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_instanceof_unrelated.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_member_closures_and_switches.ts b/crates/interpreter/tests/fixtures/classes/expect_error_member_closures_and_switches.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_member_closures_and_switches.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_member_closures_and_switches.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_member_missing_return.ts b/crates/interpreter/tests/fixtures/classes/expect_error_member_missing_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_member_missing_return.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_member_missing_return.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_member_unreachable_code.ts b/crates/interpreter/tests/fixtures/classes/expect_error_member_unreachable_code.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_member_unreachable_code.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_member_unreachable_code.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts b/crates/interpreter/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_method_switch_fallthrough.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_optional_vs_required_member.ts b/crates/interpreter/tests/fixtures/classes/expect_error_optional_vs_required_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_optional_vs_required_member.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_optional_vs_required_member.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_override_fewer_params.ts b/crates/interpreter/tests/fixtures/classes/expect_error_override_fewer_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_override_fewer_params.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_override_fewer_params.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts b/crates/interpreter/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_param_prop_outside_ctor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_readonly.ts b/crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_readonly.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_string.ts b/crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_postfix_static_string.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_postfix_static_string.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/grand.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_module/point.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_private_constructor_cross_package/shapes/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_read_write_only.ts b/crates/interpreter/tests/fixtures/classes/expect_error_read_write_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_read_write_only.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_read_write_only.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts b/crates/interpreter/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_readonly_field_vs_settable.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts b/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_redeclared_at_a_different_kind_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_accessor.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_accessor.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_class_generic.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_class_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_class_generic.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_class_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_constructor.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_constructor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_constructor.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_constructor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_field_no_init.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_field_no_init.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_field_no_init.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_field_no_init.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_instance_name_collision.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_instance_name_collision.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_instance_name_collision.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_instance_name_collision.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance_help.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance_help.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_on_instance_help.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_on_instance_help.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_optional_field.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_optional_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_optional_field.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_optional_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_this.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_this.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_this.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_this.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts b/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/mathx/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest b/crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest rename to crates/interpreter/tests/fixtures/classes/expect_error_static_via_namespace_import/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_subclass_shape_dump.ts b/crates/interpreter/tests/fixtures/classes/expect_error_subclass_shape_dump.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_subclass_shape_dump.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_subclass_shape_dump.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_to_string_signature.ts b/crates/interpreter/tests/fixtures/classes/expect_error_to_string_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_to_string_signature.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_to_string_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_type_beats_mutability.ts b/crates/interpreter/tests/fixtures/classes/expect_error_type_beats_mutability.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_type_beats_mutability.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_type_beats_mutability.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_field.ts b/crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_field.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts b/crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_uninitialized_one_branch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/expect_error_unknown_static.ts b/crates/interpreter/tests/fixtures/classes/expect_error_unknown_static.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/expect_error_unknown_static.ts rename to crates/interpreter/tests/fixtures/classes/expect_error_unknown_static.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/app/main.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_module/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_module/app/main.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_module/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/packages.manifest b/crates/interpreter/tests/fixtures/classes/extends_cross_module/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_module/packages.manifest rename to crates/interpreter/tests/fixtures/classes/extends_cross_module/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/animal.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/animal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/animal.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/animal.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/lib.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_module/zoo/lib.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_module/zoo/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/animals/lib.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_package/animals/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package/animals/lib.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_package/animals/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/dogs/lib.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_package/dogs/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package/dogs/lib.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_package/dogs/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/extends_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/extends_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_package_private/animals/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/app/main.ts b/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/app/main.ts rename to crates/interpreter/tests/fixtures/classes/extends_cross_package_private/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/packages.manifest b/crates/interpreter/tests/fixtures/classes/extends_cross_package_private/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cross_package_private/packages.manifest rename to crates/interpreter/tests/fixtures/classes/extends_cross_package_private/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_cycle.ts b/crates/interpreter/tests/fixtures/classes/extends_cycle.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_cycle.ts rename to crates/interpreter/tests/fixtures/classes/extends_cycle.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/extends_non_class.ts b/crates/interpreter/tests/fixtures/classes/extends_non_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/extends_non_class.ts rename to crates/interpreter/tests/fixtures/classes/extends_non_class.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_init_inherited.ts b/crates/interpreter/tests/fixtures/classes/field_init_inherited.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_init_inherited.ts rename to crates/interpreter/tests/fixtures/classes/field_init_inherited.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_initializers.ts b/crates/interpreter/tests/fixtures/classes/field_initializers.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_initializers.ts rename to crates/interpreter/tests/fixtures/classes/field_initializers.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_all_reads.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_all_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_all_reads.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_all_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_ancestor_view.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cast_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_constructor.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_constructor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_constructor.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_constructor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_enums.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_enums.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_enums.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_enums.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_erased_method.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_erased_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_erased_method.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_erased_method.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_factory_constructor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_box.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_box.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_box.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_box.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_context.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_context.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_context.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_context.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_factory.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_generic_payload.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_hidden_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_host_info.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_host_info.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_host_info.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_host_info.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_factory.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_nullable_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_union_interface.ts b/crates/interpreter/tests/fixtures/classes/field_narrowing_guard_union_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_narrowing_guard_union_interface.ts rename to crates/interpreter/tests/fixtures/classes/field_narrowing_guard_union_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/field_redeclared_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_in_subclass.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_in_subclass.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_in_subclass.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_in_subclass.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_narrowing_write_throws.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/field_redeclared_private_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/field_redeclared_without_initializer_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_aliased_interface.ts b/crates/interpreter/tests/fixtures/classes/implements_aliased_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_aliased_interface.ts rename to crates/interpreter/tests/fixtures/classes/implements_aliased_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_accessor.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_accessor.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/implements_inherited_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_empty_subclass.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_empty_subclass.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_empty_subclass.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_empty_subclass.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_generic_base.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_generic_base.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_generic_base.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_generic_base.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_partial_override.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_partial_override.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_partial_override.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_partial_override.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts b/crates/interpreter/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts rename to crates/interpreter/tests/fixtures/classes/implements_inherited_subclass_extra_member.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_interface.ts b/crates/interpreter/tests/fixtures/classes/implements_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_interface.ts rename to crates/interpreter/tests/fixtures/classes/implements_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implements_via_later_declared_parent.ts b/crates/interpreter/tests/fixtures/classes/implements_via_later_declared_parent.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implements_via_later_declared_parent.ts rename to crates/interpreter/tests/fixtures/classes/implements_via_later_declared_parent.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/implicit_ctor.ts b/crates/interpreter/tests/fixtures/classes/implicit_ctor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/implicit_ctor.ts rename to crates/interpreter/tests/fixtures/classes/implicit_ctor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/animals.ts b/crates/interpreter/tests/fixtures/classes/instanceof_cross_module/animals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/animals.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_module/animals.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/lib.ts b/crates/interpreter/tests/fixtures/classes/instanceof_cross_module/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_module/lib.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_module/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts b/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_package/rects/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts b/crates/interpreter/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_cross_package/shapes/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_error_chain.ts b/crates/interpreter/tests/fixtures/classes/instanceof_error_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_error_chain.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_error_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_narrow.ts b/crates/interpreter/tests/fixtures/classes/instanceof_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_narrow.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_negative.ts b/crates/interpreter/tests/fixtures/classes/instanceof_negative.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_negative.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_negative.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_sibling_same_shape.ts b/crates/interpreter/tests/fixtures/classes/instanceof_sibling_same_shape.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_sibling_same_shape.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_sibling_same_shape.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/bytes/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_generic.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_generic.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_host_built.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_host_built.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_host_built.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_host_built.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_narrow.ts b/crates/interpreter/tests/fixtures/classes/instanceof_uint8array_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_uint8array_narrow.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_uint8array_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/instanceof_unknown_lhs.ts b/crates/interpreter/tests/fixtures/classes/instanceof_unknown_lhs.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/instanceof_unknown_lhs.ts rename to crates/interpreter/tests/fixtures/classes/instanceof_unknown_lhs.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927.ts b/crates/interpreter/tests/fixtures/classes/issue_927.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927.ts rename to crates/interpreter/tests/fixtures/classes/issue_927.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927_argument_order.ts b/crates/interpreter/tests/fixtures/classes/issue_927_argument_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927_argument_order.ts rename to crates/interpreter/tests/fixtures/classes/issue_927_argument_order.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927_cycle.ts b/crates/interpreter/tests/fixtures/classes/issue_927_cycle.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927_cycle.ts rename to crates/interpreter/tests/fixtures/classes/issue_927_cycle.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927_fixed_cycle.ts b/crates/interpreter/tests/fixtures/classes/issue_927_fixed_cycle.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927_fixed_cycle.ts rename to crates/interpreter/tests/fixtures/classes/issue_927_fixed_cycle.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927_interface.ts b/crates/interpreter/tests/fixtures/classes/issue_927_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927_interface.ts rename to crates/interpreter/tests/fixtures/classes/issue_927_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_927_union_cycle.ts b/crates/interpreter/tests/fixtures/classes/issue_927_union_cycle.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_927_union_cycle.ts rename to crates/interpreter/tests/fixtures/classes/issue_927_union_cycle.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_967_checked_return_abi.ts b/crates/interpreter/tests/fixtures/classes/issue_967_checked_return_abi.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_967_checked_return_abi.ts rename to crates/interpreter/tests/fixtures/classes/issue_967_checked_return_abi.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_967_default_interface.ts b/crates/interpreter/tests/fixtures/classes/issue_967_default_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_967_default_interface.ts rename to crates/interpreter/tests/fixtures/classes/issue_967_default_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_967_required.ts b/crates/interpreter/tests/fixtures/classes/issue_967_required.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_967_required.ts rename to crates/interpreter/tests/fixtures/classes/issue_967_required.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_967_structural_defaults.ts b/crates/interpreter/tests/fixtures/classes/issue_967_structural_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_967_structural_defaults.ts rename to crates/interpreter/tests/fixtures/classes/issue_967_structural_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_967_wrong_parameter.ts b/crates/interpreter/tests/fixtures/classes/issue_967_wrong_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_967_wrong_parameter.ts rename to crates/interpreter/tests/fixtures/classes/issue_967_wrong_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_973_shorthand_boundary.ts b/crates/interpreter/tests/fixtures/classes/issue_973_shorthand_boundary.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_973_shorthand_boundary.ts rename to crates/interpreter/tests/fixtures/classes/issue_973_shorthand_boundary.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_987_inline_object.ts b/crates/interpreter/tests/fixtures/classes/issue_987_inline_object.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_987_inline_object.ts rename to crates/interpreter/tests/fixtures/classes/issue_987_inline_object.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_987_private.ts b/crates/interpreter/tests/fixtures/classes/issue_987_private.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_987_private.ts rename to crates/interpreter/tests/fixtures/classes/issue_987_private.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_987_setter_only.ts b/crates/interpreter/tests/fixtures/classes/issue_987_setter_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_987_setter_only.ts rename to crates/interpreter/tests/fixtures/classes/issue_987_setter_only.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/issue_987_weak_target.ts b/crates/interpreter/tests/fixtures/classes/issue_987_weak_target.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/issue_987_weak_target.ts rename to crates/interpreter/tests/fixtures/classes/issue_987_weak_target.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/app/main.ts b/crates/interpreter/tests/fixtures/classes/json_inherited_private/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/json_inherited_private/app/main.ts rename to crates/interpreter/tests/fixtures/classes/json_inherited_private/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/json_inherited_private/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/json_inherited_private/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/json_inherited_private/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/json_inherited_private/packages.manifest b/crates/interpreter/tests/fixtures/classes/json_inherited_private/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/json_inherited_private/packages.manifest rename to crates/interpreter/tests/fixtures/classes/json_inherited_private/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/json_public_properties.ts b/crates/interpreter/tests/fixtures/classes/json_public_properties.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/json_public_properties.ts rename to crates/interpreter/tests/fixtures/classes/json_public_properties.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/map_set_class_keys.ts b/crates/interpreter/tests/fixtures/classes/map_set_class_keys.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/map_set_class_keys.ts rename to crates/interpreter/tests/fixtures/classes/map_set_class_keys.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/method_dispatch.ts b/crates/interpreter/tests/fixtures/classes/method_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/method_dispatch.ts rename to crates/interpreter/tests/fixtures/classes/method_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/method_rewritten_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/method_rewritten_through_alias.ts b/crates/interpreter/tests/fixtures/classes/method_rewritten_through_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/method_rewritten_through_alias.ts rename to crates/interpreter/tests/fixtures/classes/method_rewritten_through_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts b/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts rename to crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/errs/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/multi_catch_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/multi_catch_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts b/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts rename to crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/mutable_conversion_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/object_literal_in_member_bodies.ts b/crates/interpreter/tests/fixtures/classes/object_literal_in_member_bodies.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/object_literal_in_member_bodies.ts rename to crates/interpreter/tests/fixtures/classes/object_literal_in_member_bodies.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/overridden_defaults.ts b/crates/interpreter/tests/fixtures/classes/overridden_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/overridden_defaults.ts rename to crates/interpreter/tests/fixtures/classes/overridden_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/param_properties.ts b/crates/interpreter/tests/fixtures/classes/param_properties.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/param_properties.ts rename to crates/interpreter/tests/fixtures/classes/param_properties.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/permission_denied_error_builtin.ts b/crates/interpreter/tests/fixtures/classes/permission_denied_error_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/permission_denied_error_builtin.ts rename to crates/interpreter/tests/fixtures/classes/permission_denied_error_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/postfix_field_expression.ts b/crates/interpreter/tests/fixtures/classes/postfix_field_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/postfix_field_expression.ts rename to crates/interpreter/tests/fixtures/classes/postfix_field_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/app/main.ts b/crates/interpreter/tests/fixtures/classes/private_constructor_packages/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/app/main.ts rename to crates/interpreter/tests/fixtures/classes/private_constructor_packages/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/packages.manifest b/crates/interpreter/tests/fixtures/classes/private_constructor_packages/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/packages.manifest rename to crates/interpreter/tests/fixtures/classes/private_constructor_packages/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts b/crates/interpreter/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts rename to crates/interpreter/tests/fixtures/classes/private_constructor_packages/shapes/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/private_cross_module/animal.ts b/crates/interpreter/tests/fixtures/classes/private_cross_module/animal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/private_cross_module/animal.ts rename to crates/interpreter/tests/fixtures/classes/private_cross_module/animal.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/private_cross_module/lib.ts b/crates/interpreter/tests/fixtures/classes/private_cross_module/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/private_cross_module/lib.ts rename to crates/interpreter/tests/fixtures/classes/private_cross_module/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/protected_member.ts b/crates/interpreter/tests/fixtures/classes/protected_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/protected_member.ts rename to crates/interpreter/tests/fixtures/classes/protected_member.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/quota_exceeded_error.ts b/crates/interpreter/tests/fixtures/classes/quota_exceeded_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/quota_exceeded_error.ts rename to crates/interpreter/tests/fixtures/classes/quota_exceeded_error.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/range_error_builtin.ts b/crates/interpreter/tests/fixtures/classes/range_error_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/range_error_builtin.ts rename to crates/interpreter/tests/fixtures/classes/range_error_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/range_error_host_throws.ts b/crates/interpreter/tests/fixtures/classes/range_error_host_throws.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/range_error_host_throws.ts rename to crates/interpreter/tests/fixtures/classes/range_error_host_throws.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/readonly_write_outside_ctor.ts b/crates/interpreter/tests/fixtures/classes/readonly_write_outside_ctor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/readonly_write_outside_ctor.ts rename to crates/interpreter/tests/fixtures/classes/readonly_write_outside_ctor.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts b/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts rename to crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/a/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts b/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts rename to crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts b/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts rename to crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/b/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest b/crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest rename to crates/interpreter/tests/fixtures/classes/recursive_guard_same_name_packages/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/setter_assignment_as_value.ts b/crates/interpreter/tests/fixtures/classes/setter_assignment_as_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/setter_assignment_as_value.ts rename to crates/interpreter/tests/fixtures/classes/setter_assignment_as_value.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_and_instance_same_name.ts b/crates/interpreter/tests/fixtures/classes/static_and_instance_same_name.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_and_instance_same_name.ts rename to crates/interpreter/tests/fixtures/classes/static_and_instance_same_name.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/static_classref_ancestor_only_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/static_classref_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/static_classref_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/static_classref_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_classref_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/static_classref_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/static_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/static_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/static_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_cross_package/mathx/lib.ts b/crates/interpreter/tests/fixtures/classes/static_cross_package/mathx/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_cross_package/mathx/lib.ts rename to crates/interpreter/tests/fixtures/classes/static_cross_package/mathx/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/static_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/static_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/static_generic_method.ts b/crates/interpreter/tests/fixtures/classes/static_generic_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_generic_method.ts rename to crates/interpreter/tests/fixtures/classes/static_generic_method.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_inheritance.ts b/crates/interpreter/tests/fixtures/classes/static_inheritance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_inheritance.ts rename to crates/interpreter/tests/fixtures/classes/static_inheritance.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_instance_name_collision.ts b/crates/interpreter/tests/fixtures/classes/static_instance_name_collision.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_instance_name_collision.ts rename to crates/interpreter/tests/fixtures/classes/static_instance_name_collision.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_members_do_not_redeclare.ts b/crates/interpreter/tests/fixtures/classes/static_members_do_not_redeclare.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_members_do_not_redeclare.ts rename to crates/interpreter/tests/fixtures/classes/static_members_do_not_redeclare.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_method_as_value.ts b/crates/interpreter/tests/fixtures/classes/static_method_as_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_method_as_value.ts rename to crates/interpreter/tests/fixtures/classes/static_method_as_value.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_method_basic.ts b/crates/interpreter/tests/fixtures/classes/static_method_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_method_basic.ts rename to crates/interpreter/tests/fixtures/classes/static_method_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_assign.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_assign.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_assign.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_assign.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/counters/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/static_mutable_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_field.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_field.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_inherited_write.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_inherited_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_inherited_write.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_inherited_write.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_postfix.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_postfix.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_postfix.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_postfix.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_mutable_private.ts b/crates/interpreter/tests/fixtures/classes/static_mutable_private.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_mutable_private.ts rename to crates/interpreter/tests/fixtures/classes/static_mutable_private.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_private.ts b/crates/interpreter/tests/fixtures/classes/static_private.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_private.ts rename to crates/interpreter/tests/fixtures/classes/static_private.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_readonly_field.ts b/crates/interpreter/tests/fixtures/classes/static_readonly_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_readonly_field.ts rename to crates/interpreter/tests/fixtures/classes/static_readonly_field.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts b/crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts rename to crates/interpreter/tests/fixtures/classes/static_ref_types_cross_package/strx/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/super_chain.ts b/crates/interpreter/tests/fixtures/classes/super_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/super_chain.ts rename to crates/interpreter/tests/fixtures/classes/super_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/super_ctor_field_init.ts b/crates/interpreter/tests/fixtures/classes/super_ctor_field_init.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/super_ctor_field_init.ts rename to crates/interpreter/tests/fixtures/classes/super_ctor_field_init.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/super_method_override.ts b/crates/interpreter/tests/fixtures/classes/super_method_override.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/super_method_override.ts rename to crates/interpreter/tests/fixtures/classes/super_method_override.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/syntax_error_builtin.ts b/crates/interpreter/tests/fixtures/classes/syntax_error_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/syntax_error_builtin.ts rename to crates/interpreter/tests/fixtures/classes/syntax_error_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/this_in_field_initializer.ts b/crates/interpreter/tests/fixtures/classes/this_in_field_initializer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/this_in_field_initializer.ts rename to crates/interpreter/tests/fixtures/classes/this_in_field_initializer.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/this_outside_method.ts b/crates/interpreter/tests/fixtures/classes/this_outside_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/this_outside_method.ts rename to crates/interpreter/tests/fixtures/classes/this_outside_method.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib1/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/lib2/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/transitive_dep_closure_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib1/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/lib2/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts b/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts rename to crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/transitive_dep_not_importable_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/type_error_builtin.ts b/crates/interpreter/tests/fixtures/classes/type_error_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/type_error_builtin.ts rename to crates/interpreter/tests/fixtures/classes/type_error_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/type_error_host_thrown.ts b/crates/interpreter/tests/fixtures/classes/type_error_host_thrown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/type_error_host_thrown.ts rename to crates/interpreter/tests/fixtures/classes/type_error_host_thrown.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts b/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts rename to crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/errs/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/typed_catch_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/typed_catch_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/undefined_reference_error.ts b/crates/interpreter/tests/fixtures/classes/undefined_reference_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/undefined_reference_error.ts rename to crates/interpreter/tests/fixtures/classes/undefined_reference_error.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/universal_to_json.ts b/crates/interpreter/tests/fixtures/classes/universal_to_json.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/universal_to_json.ts rename to crates/interpreter/tests/fixtures/classes/universal_to_json.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/universal_to_string.ts b/crates/interpreter/tests/fixtures/classes/universal_to_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/universal_to_string.ts rename to crates/interpreter/tests/fixtures/classes/universal_to_string.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts b/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts rename to crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts b/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts rename to crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/consumer/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts b/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts rename to crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/unused_static_thirdpkg_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/classes/unused_statics_not_imported_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/closure_captures_class_union.ts b/crates/interpreter/tests/fixtures/closure_captures_class_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_captures_class_union.ts rename to crates/interpreter/tests/fixtures/closure_captures_class_union.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/closure_coercion_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/closure_coercion_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/closure_coercion_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/closure_coercion_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/closure_coercion_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_coercion_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/closure_coercion_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/closure_counter.subm b/crates/interpreter/tests/fixtures/closure_counter.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_counter.subm rename to crates/interpreter/tests/fixtures/closure_counter.subm diff --git a/crates/submilli-engine/tests/fixtures/closure_nullable_return.ts b/crates/interpreter/tests/fixtures/closure_nullable_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_nullable_return.ts rename to crates/interpreter/tests/fixtures/closure_nullable_return.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_reads_later_module_variable.ts b/crates/interpreter/tests/fixtures/closure_reads_later_module_variable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_reads_later_module_variable.ts rename to crates/interpreter/tests/fixtures/closure_reads_later_module_variable.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_accessor_dispatch.ts b/crates/interpreter/tests/fixtures/closure_sig_accessor_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_accessor_dispatch.ts rename to crates/interpreter/tests/fixtures/closure_sig_accessor_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_after_substitution.ts b/crates/interpreter/tests/fixtures/closure_sig_after_substitution.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_after_substitution.ts rename to crates/interpreter/tests/fixtures/closure_sig_after_substitution.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_from_class_members.ts b/crates/interpreter/tests/fixtures/closure_sig_from_class_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_from_class_members.ts rename to crates/interpreter/tests/fixtures/closure_sig_from_class_members.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_from_local_slot.ts b/crates/interpreter/tests/fixtures/closure_sig_from_local_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_from_local_slot.ts rename to crates/interpreter/tests/fixtures/closure_sig_from_local_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_from_uncalled_signatures.ts b/crates/interpreter/tests/fixtures/closure_sig_from_uncalled_signatures.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_from_uncalled_signatures.ts rename to crates/interpreter/tests/fixtures/closure_sig_from_uncalled_signatures.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_sig_shape_dispatch.ts b/crates/interpreter/tests/fixtures/closure_sig_shape_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_sig_shape_dispatch.ts rename to crates/interpreter/tests/fixtures/closure_sig_shape_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_that_only_throws_is_never.ts b/crates/interpreter/tests/fixtures/closure_that_only_throws_is_never.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_that_only_throws_is_never.ts rename to crates/interpreter/tests/fixtures/closure_that_only_throws_is_never.ts diff --git a/crates/submilli-engine/tests/fixtures/closure_variable_passed_to_hof.subm b/crates/interpreter/tests/fixtures/closure_variable_passed_to_hof.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/closure_variable_passed_to_hof.subm rename to crates/interpreter/tests/fixtures/closure_variable_passed_to_hof.subm diff --git a/crates/submilli-engine/tests/fixtures/closures/callbacks_declare_fewer_params.ts b/crates/interpreter/tests/fixtures/closures/callbacks_declare_fewer_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/callbacks_declare_fewer_params.ts rename to crates/interpreter/tests/fixtures/closures/callbacks_declare_fewer_params.ts diff --git a/crates/submilli-engine/tests/fixtures/closures/function_arity_edges.ts b/crates/interpreter/tests/fixtures/closures/function_arity_edges.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/function_arity_edges.ts rename to crates/interpreter/tests/fixtures/closures/function_arity_edges.ts diff --git a/crates/submilli-engine/tests/fixtures/closures/function_this.ts b/crates/interpreter/tests/fixtures/closures/function_this.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/function_this.ts rename to crates/interpreter/tests/fixtures/closures/function_this.ts diff --git a/crates/submilli-engine/tests/fixtures/closures/iife.subm b/crates/interpreter/tests/fixtures/closures/iife.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/iife.subm rename to crates/interpreter/tests/fixtures/closures/iife.subm diff --git a/crates/submilli-engine/tests/fixtures/closures/named_function_expression.ts b/crates/interpreter/tests/fixtures/closures/named_function_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/named_function_expression.ts rename to crates/interpreter/tests/fixtures/closures/named_function_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/closures/nested_function_contexts.ts b/crates/interpreter/tests/fixtures/closures/nested_function_contexts.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/nested_function_contexts.ts rename to crates/interpreter/tests/fixtures/closures/nested_function_contexts.ts diff --git a/crates/submilli-engine/tests/fixtures/closures/nested_function_declarations.ts b/crates/interpreter/tests/fixtures/closures/nested_function_declarations.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/closures/nested_function_declarations.ts rename to crates/interpreter/tests/fixtures/closures/nested_function_declarations.ts diff --git a/crates/submilli-engine/tests/fixtures/code/linear_diff.ts b/crates/interpreter/tests/fixtures/code/linear_diff.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/code/linear_diff.ts rename to crates/interpreter/tests/fixtures/code/linear_diff.ts diff --git a/crates/submilli-engine/tests/fixtures/code/workspace.ts b/crates/interpreter/tests/fixtures/code/workspace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/code/workspace.ts rename to crates/interpreter/tests/fixtures/code/workspace.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_iterators_live.ts b/crates/interpreter/tests/fixtures/collection_iterators_live.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_iterators_live.ts rename to crates/interpreter/tests/fixtures/collection_iterators_live.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_keys_same_value_zero.ts b/crates/interpreter/tests/fixtures/collection_keys_same_value_zero.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_keys_same_value_zero.ts rename to crates/interpreter/tests/fixtures/collection_keys_same_value_zero.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/array_from_mapping.ts b/crates/interpreter/tests/fixtures/collection_regressions/array_from_mapping.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/array_from_mapping.ts rename to crates/interpreter/tests/fixtures/collection_regressions/array_from_mapping.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/array_from_nullable.ts b/crates/interpreter/tests/fixtures/collection_regressions/array_from_nullable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/array_from_nullable.ts rename to crates/interpreter/tests/fixtures/collection_regressions/array_from_nullable.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/array_postfix_only.ts b/crates/interpreter/tests/fixtures/collection_regressions/array_postfix_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/array_postfix_only.ts rename to crates/interpreter/tests/fixtures/collection_regressions/array_postfix_only.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts b/crates/interpreter/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts rename to crates/interpreter/tests/fixtures/collection_regressions/expect_error_optional_tuple_index.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_arity.ts b/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_arity.ts rename to crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_array.ts b/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_array.ts rename to crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_array.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_slot.ts b/crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/expect_error_spread_slot.ts rename to crates/interpreter/tests/fixtures/collection_regressions/expect_error_spread_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/optional_index.ts b/crates/interpreter/tests/fixtures/collection_regressions/optional_index.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/optional_index.ts rename to crates/interpreter/tests/fixtures/collection_regressions/optional_index.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/optional_index_bounds.ts b/crates/interpreter/tests/fixtures/collection_regressions/optional_index_bounds.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/optional_index_bounds.ts rename to crates/interpreter/tests/fixtures/collection_regressions/optional_index_bounds.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/spread_order.ts b/crates/interpreter/tests/fixtures/collection_regressions/spread_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/spread_order.ts rename to crates/interpreter/tests/fixtures/collection_regressions/spread_order.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/tuple_boxing.ts b/crates/interpreter/tests/fixtures/collection_regressions/tuple_boxing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/tuple_boxing.ts rename to crates/interpreter/tests/fixtures/collection_regressions/tuple_boxing.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/tuple_spread.ts b/crates/interpreter/tests/fixtures/collection_regressions/tuple_spread.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/tuple_spread.ts rename to crates/interpreter/tests/fixtures/collection_regressions/tuple_spread.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix.ts b/crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix.ts rename to crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix_only.ts b/crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_regressions/uint8_postfix_only.ts rename to crates/interpreter/tests/fixtures/collection_regressions/uint8_postfix_only.ts diff --git a/crates/submilli-engine/tests/fixtures/collection_to_string_tag.ts b/crates/interpreter/tests/fixtures/collection_to_string_tag.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/collection_to_string_tag.ts rename to crates/interpreter/tests/fixtures/collection_to_string_tag.ts diff --git a/crates/submilli-engine/tests/fixtures/comparable_methods_and_self_references.ts b/crates/interpreter/tests/fixtures/comparable_methods_and_self_references.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/comparable_methods_and_self_references.ts rename to crates/interpreter/tests/fixtures/comparable_methods_and_self_references.ts diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_basic_number.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_basic_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_basic_number.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_basic_number.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_bigint.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_bigint.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_bigint.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_bigint.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_const_error.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_const_error.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_const_error.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_const_error.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_field.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_field.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_field.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_for_loop.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_for_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_for_loop.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_for_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_index.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_index.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_index.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_index.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_narrowing.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_narrowing.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_pow_precedence.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_pow_precedence.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_pow_precedence.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_pow_precedence.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_string.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_string.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_string.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_mixed.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_type_error_mixed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_mixed.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_type_error_mixed.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_string_sub.subm b/crates/interpreter/tests/fixtures/compound_assign/compound_type_error_string_sub.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/compound_type_error_string_sub.subm rename to crates/interpreter/tests/fixtures/compound_assign/compound_type_error_string_sub.subm diff --git a/crates/submilli-engine/tests/fixtures/compound_assign/receiver_evaluated_once.ts b/crates/interpreter/tests/fixtures/compound_assign/receiver_evaluated_once.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assign/receiver_evaluated_once.ts rename to crates/interpreter/tests/fixtures/compound_assign/receiver_evaluated_once.ts diff --git a/crates/submilli-engine/tests/fixtures/compound_assignment_through_never_getter.ts b/crates/interpreter/tests/fixtures/compound_assignment_through_never_getter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_assignment_through_never_getter.ts rename to crates/interpreter/tests/fixtures/compound_assignment_through_never_getter.ts diff --git a/crates/submilli-engine/tests/fixtures/compound_write_widens_literal_target.ts b/crates/interpreter/tests/fixtures/compound_write_widens_literal_target.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/compound_write_widens_literal_target.ts rename to crates/interpreter/tests/fixtures/compound_write_widens_literal_target.ts diff --git a/crates/submilli-engine/tests/fixtures/conditional_object_literal_normalization.ts b/crates/interpreter/tests/fixtures/conditional_object_literal_normalization.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/conditional_object_literal_normalization.ts rename to crates/interpreter/tests/fixtures/conditional_object_literal_normalization.ts diff --git a/crates/submilli-engine/tests/fixtures/conformance_array.subm b/crates/interpreter/tests/fixtures/conformance_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_array.subm rename to crates/interpreter/tests/fixtures/conformance_array.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_bigint.subm b/crates/interpreter/tests/fixtures/conformance_bigint.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_bigint.subm rename to crates/interpreter/tests/fixtures/conformance_bigint.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_boolean.subm b/crates/interpreter/tests/fixtures/conformance_boolean.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_boolean.subm rename to crates/interpreter/tests/fixtures/conformance_boolean.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_json.subm b/crates/interpreter/tests/fixtures/conformance_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_json.subm rename to crates/interpreter/tests/fixtures/conformance_json.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_map_set.subm b/crates/interpreter/tests/fixtures/conformance_map_set.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_map_set.subm rename to crates/interpreter/tests/fixtures/conformance_map_set.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_math.subm b/crates/interpreter/tests/fixtures/conformance_math.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_math.subm rename to crates/interpreter/tests/fixtures/conformance_math.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_number.subm b/crates/interpreter/tests/fixtures/conformance_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_number.subm rename to crates/interpreter/tests/fixtures/conformance_number.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_object.subm b/crates/interpreter/tests/fixtures/conformance_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_object.subm rename to crates/interpreter/tests/fixtures/conformance_object.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_regexp.subm b/crates/interpreter/tests/fixtures/conformance_regexp.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_regexp.subm rename to crates/interpreter/tests/fixtures/conformance_regexp.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_string.subm b/crates/interpreter/tests/fixtures/conformance_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_string.subm rename to crates/interpreter/tests/fixtures/conformance_string.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_temporal.subm b/crates/interpreter/tests/fixtures/conformance_temporal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_temporal.subm rename to crates/interpreter/tests/fixtures/conformance_temporal.subm diff --git a/crates/submilli-engine/tests/fixtures/conformance_uint8array.subm b/crates/interpreter/tests/fixtures/conformance_uint8array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/conformance_uint8array.subm rename to crates/interpreter/tests/fixtures/conformance_uint8array.subm diff --git a/crates/submilli-engine/tests/fixtures/console_log_null.ts b/crates/interpreter/tests/fixtures/console_log_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/console_log_null.ts rename to crates/interpreter/tests/fixtures/console_log_null.ts diff --git a/crates/submilli-engine/tests/fixtures/console_log_variadic.subm b/crates/interpreter/tests/fixtures/console_log_variadic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/console_log_variadic.subm rename to crates/interpreter/tests/fixtures/console_log_variadic.subm diff --git a/crates/submilli-engine/tests/fixtures/const_keeps_literals_through_operators.ts b/crates/interpreter/tests/fixtures/const_keeps_literals_through_operators.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/const_keeps_literals_through_operators.ts rename to crates/interpreter/tests/fixtures/const_keeps_literals_through_operators.ts diff --git a/crates/submilli-engine/tests/fixtures/const_literal_survives_through_ternaries.ts b/crates/interpreter/tests/fixtures/const_literal_survives_through_ternaries.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/const_literal_survives_through_ternaries.ts rename to crates/interpreter/tests/fixtures/const_literal_survives_through_ternaries.ts diff --git a/crates/submilli-engine/tests/fixtures/const_literal_survives_where_immutable.ts b/crates/interpreter/tests/fixtures/const_literal_survives_where_immutable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/const_literal_survives_where_immutable.ts rename to crates/interpreter/tests/fixtures/const_literal_survives_where_immutable.ts diff --git a/crates/submilli-engine/tests/fixtures/const_literal_widens_where_mutable.ts b/crates/interpreter/tests/fixtures/const_literal_widens_where_mutable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/const_literal_widens_where_mutable.ts rename to crates/interpreter/tests/fixtures/const_literal_widens_where_mutable.ts diff --git a/crates/submilli-engine/tests/fixtures/constant_expression_literal_types.ts b/crates/interpreter/tests/fixtures/constant_expression_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/constant_expression_literal_types.ts rename to crates/interpreter/tests/fixtures/constant_expression_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/constant_key_reads_as_field.ts b/crates/interpreter/tests/fixtures/constant_key_reads_as_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/constant_key_reads_as_field.ts rename to crates/interpreter/tests/fixtures/constant_key_reads_as_field.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/all_five_as_names.ts b/crates/interpreter/tests/fixtures/contextual-keywords/all_five_as_names.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/all_five_as_names.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/all_five_as_names.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts b/crates/interpreter/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/asi_newline_before_as_splits.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts b/crates/interpreter/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/for_of_binding_named_of.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/from_binding_template.ts b/crates/interpreter/tests/fixtures/contextual-keywords/from_binding_template.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/from_binding_template.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/from_binding_template.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts b/crates/interpreter/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/keyword_positions_still_work.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_inline.ts b/crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_inline.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_inline.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_inline.ts diff --git a/crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_statement.ts b/crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_statement.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/contextual-keywords/type_only_import_statement.ts rename to crates/interpreter/tests/fixtures/contextual-keywords/type_only_import_statement.ts diff --git a/crates/submilli-engine/tests/fixtures/conversion_field_rest_and_this.ts b/crates/interpreter/tests/fixtures/conversion_field_rest_and_this.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/conversion_field_rest_and_this.ts rename to crates/interpreter/tests/fixtures/conversion_field_rest_and_this.ts diff --git a/crates/submilli-engine/tests/fixtures/crypto/hmac_sha256.subm b/crates/interpreter/tests/fixtures/crypto/hmac_sha256.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/crypto/hmac_sha256.subm rename to crates/interpreter/tests/fixtures/crypto/hmac_sha256.subm diff --git a/crates/submilli-engine/tests/fixtures/crypto/random_bytes.subm b/crates/interpreter/tests/fixtures/crypto/random_bytes.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/crypto/random_bytes.subm rename to crates/interpreter/tests/fixtures/crypto/random_bytes.subm diff --git a/crates/submilli-engine/tests/fixtures/crypto/sha256.subm b/crates/interpreter/tests/fixtures/crypto/sha256.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/crypto/sha256.subm rename to crates/interpreter/tests/fixtures/crypto/sha256.subm diff --git a/crates/submilli-engine/tests/fixtures/crypto/sha512.subm b/crates/interpreter/tests/fixtures/crypto/sha512.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/crypto/sha512.subm rename to crates/interpreter/tests/fixtures/crypto/sha512.subm diff --git a/crates/submilli-engine/tests/fixtures/crypto/timing_safe_equal.subm b/crates/interpreter/tests/fixtures/crypto/timing_safe_equal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/crypto/timing_safe_equal.subm rename to crates/interpreter/tests/fixtures/crypto/timing_safe_equal.subm diff --git a/crates/submilli-engine/tests/fixtures/cyclic_graph_host_walk.ts b/crates/interpreter/tests/fixtures/cyclic_graph_host_walk.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/cyclic_graph_host_walk.ts rename to crates/interpreter/tests/fixtures/cyclic_graph_host_walk.ts diff --git a/crates/submilli-engine/tests/fixtures/date_lowercase_variable_works.subm b/crates/interpreter/tests/fixtures/date_lowercase_variable_works.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/date_lowercase_variable_works.subm rename to crates/interpreter/tests/fixtures/date_lowercase_variable_works.subm diff --git a/crates/submilli-engine/tests/fixtures/decode_uri_lone_surrogates.ts b/crates/interpreter/tests/fixtures/decode_uri_lone_surrogates.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/decode_uri_lone_surrogates.ts rename to crates/interpreter/tests/fixtures/decode_uri_lone_surrogates.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_arrow.ts b/crates/interpreter/tests/fixtures/default_param_arrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_arrow.ts rename to crates/interpreter/tests/fixtures/default_param_arrow.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_basic.subm b/crates/interpreter/tests/fixtures/default_param_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_basic.subm rename to crates/interpreter/tests/fixtures/default_param_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/default_param_before_required.ts b/crates/interpreter/tests/fixtures/default_param_before_required.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_before_required.ts rename to crates/interpreter/tests/fixtures/default_param_before_required.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_boxed_slot.ts b/crates/interpreter/tests/fixtures/default_param_boxed_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_boxed_slot.ts rename to crates/interpreter/tests/fixtures/default_param_boxed_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_enum_variant.subm b/crates/interpreter/tests/fixtures/default_param_enum_variant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_enum_variant.subm rename to crates/interpreter/tests/fixtures/default_param_enum_variant.subm diff --git a/crates/submilli-engine/tests/fixtures/default_param_expression.ts b/crates/interpreter/tests/fixtures/default_param_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_expression.ts rename to crates/interpreter/tests/fixtures/default_param_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_global_const.ts b/crates/interpreter/tests/fixtures/default_param_global_const.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_global_const.ts rename to crates/interpreter/tests/fixtures/default_param_global_const.ts diff --git a/crates/submilli-engine/tests/fixtures/default_param_method.subm b/crates/interpreter/tests/fixtures/default_param_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/default_param_method.subm rename to crates/interpreter/tests/fixtures/default_param_method.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/array_hole.subm b/crates/interpreter/tests/fixtures/destructuring/array_hole.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/array_hole.subm rename to crates/interpreter/tests/fixtures/destructuring/array_hole.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/array_literal_as_tuple.subm b/crates/interpreter/tests/fixtures/destructuring/array_literal_as_tuple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/array_literal_as_tuple.subm rename to crates/interpreter/tests/fixtures/destructuring/array_literal_as_tuple.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/array_positional.subm b/crates/interpreter/tests/fixtures/destructuring/array_positional.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/array_positional.subm rename to crates/interpreter/tests/fixtures/destructuring/array_positional.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/array_rest.subm b/crates/interpreter/tests/fixtures/destructuring/array_rest.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/array_rest.subm rename to crates/interpreter/tests/fixtures/destructuring/array_rest.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/arrow_param_expr_body.subm b/crates/interpreter/tests/fixtures/destructuring/arrow_param_expr_body.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/arrow_param_expr_body.subm rename to crates/interpreter/tests/fixtures/destructuring/arrow_param_expr_body.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/class_member_params.ts b/crates/interpreter/tests/fixtures/destructuring/class_member_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/class_member_params.ts rename to crates/interpreter/tests/fixtures/destructuring/class_member_params.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts b/crates/interpreter/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts rename to crates/interpreter/tests/fixtures/destructuring/defaults_pad_literal_tuple.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts b/crates/interpreter/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts rename to crates/interpreter/tests/fixtures/destructuring/expect_error_annotated_undefined_component_default.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_array_literal_arity.subm b/crates/interpreter/tests/fixtures/destructuring/expect_error_array_literal_arity.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_array_literal_arity.subm rename to crates/interpreter/tests/fixtures/destructuring/expect_error_array_literal_arity.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts b/crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts rename to crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts b/crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts rename to crates/interpreter/tests/fixtures/destructuring/expect_error_for_initializer_parse.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_arity.subm b/crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_arity.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_arity.subm rename to crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_arity.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm b/crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm rename to crates/interpreter/tests/fixtures/destructuring/expect_error_for_of_non_tuple.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_nested.subm b/crates/interpreter/tests/fixtures/destructuring/expect_error_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_nested.subm rename to crates/interpreter/tests/fixtures/destructuring/expect_error_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts b/crates/interpreter/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts rename to crates/interpreter/tests/fixtures/destructuring/expect_error_pattern_longer_than_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/expect_error_rest_not_last.subm b/crates/interpreter/tests/fixtures/destructuring/expect_error_rest_not_last.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/expect_error_rest_not_last.subm rename to crates/interpreter/tests/fixtures/destructuring/expect_error_rest_not_last.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/for_initializer.ts b/crates/interpreter/tests/fixtures/destructuring/for_initializer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/for_initializer.ts rename to crates/interpreter/tests/fixtures/destructuring/for_initializer.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/for_of_map.subm b/crates/interpreter/tests/fixtures/destructuring/for_of_map.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/for_of_map.subm rename to crates/interpreter/tests/fixtures/destructuring/for_of_map.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/for_of_tuple.subm b/crates/interpreter/tests/fixtures/destructuring/for_of_tuple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/for_of_tuple.subm rename to crates/interpreter/tests/fixtures/destructuring/for_of_tuple.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/function_param.subm b/crates/interpreter/tests/fixtures/destructuring/function_param.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/function_param.subm rename to crates/interpreter/tests/fixtures/destructuring/function_param.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/let_pattern_mutation.subm b/crates/interpreter/tests/fixtures/destructuring/let_pattern_mutation.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/let_pattern_mutation.subm rename to crates/interpreter/tests/fixtures/destructuring/let_pattern_mutation.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/nested_in_block.subm b/crates/interpreter/tests/fixtures/destructuring/nested_in_block.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/nested_in_block.subm rename to crates/interpreter/tests/fixtures/destructuring/nested_in_block.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/object_rename.subm b/crates/interpreter/tests/fixtures/destructuring/object_rename.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/object_rename.subm rename to crates/interpreter/tests/fixtures/destructuring/object_rename.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/object_rest.subm b/crates/interpreter/tests/fixtures/destructuring/object_rest.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/object_rest.subm rename to crates/interpreter/tests/fixtures/destructuring/object_rest.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/object_shorthand.subm b/crates/interpreter/tests/fixtures/destructuring/object_shorthand.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/object_shorthand.subm rename to crates/interpreter/tests/fixtures/destructuring/object_shorthand.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring/parameter_defaults.ts b/crates/interpreter/tests/fixtures/destructuring/parameter_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/parameter_defaults.ts rename to crates/interpreter/tests/fixtures/destructuring/parameter_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/pattern_defaults.ts b/crates/interpreter/tests/fixtures/destructuring/pattern_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/pattern_defaults.ts rename to crates/interpreter/tests/fixtures/destructuring/pattern_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/destructuring/single_eval_rhs.subm b/crates/interpreter/tests/fixtures/destructuring/single_eval_rhs.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring/single_eval_rhs.subm rename to crates/interpreter/tests/fixtures/destructuring/single_eval_rhs.subm diff --git a/crates/submilli-engine/tests/fixtures/destructuring_initializer_flow.ts b/crates/interpreter/tests/fixtures/destructuring_initializer_flow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/destructuring_initializer_flow.ts rename to crates/interpreter/tests/fixtures/destructuring_initializer_flow.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/accessor.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/accessor.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/array.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/array.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/array.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/getter.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/getter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/getter.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/getter.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/interface.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/interface.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/interface.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/dep/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings/root/main.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/dep/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/package_warnings_error/root/main.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_array.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/spread_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_array.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/spread_array.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_tuple.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/spread_tuple.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/spread_tuple.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/spread_tuple.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/tuple.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/tuple.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/tuple.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/tuple.ts diff --git a/crates/submilli-engine/tests/fixtures/diagnostic_counts/unhinted_array.ts b/crates/interpreter/tests/fixtures/diagnostic_counts/unhinted_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/diagnostic_counts/unhinted_array.ts rename to crates/interpreter/tests/fixtures/diagnostic_counts/unhinted_array.ts diff --git a/crates/submilli-engine/tests/fixtures/discriminated_union_object_literal.subm b/crates/interpreter/tests/fixtures/discriminated_union_object_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/discriminated_union_object_literal.subm rename to crates/interpreter/tests/fixtures/discriminated_union_object_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/doc_callable_members.ts b/crates/interpreter/tests/fixtures/doc_callable_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_callable_members.ts rename to crates/interpreter/tests/fixtures/doc_callable_members.ts diff --git a/crates/submilli-engine/tests/fixtures/doc_comments/capability_context_fields.ts b/crates/interpreter/tests/fixtures/doc_comments/capability_context_fields.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_comments/capability_context_fields.ts rename to crates/interpreter/tests/fixtures/doc_comments/capability_context_fields.ts diff --git a/crates/submilli-engine/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts b/crates/interpreter/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts rename to crates/interpreter/tests/fixtures/doc_comments/expect_error_payload_key_missing_from_capability_doc.ts diff --git a/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm b/crates/interpreter/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm rename to crates/interpreter/tests/fixtures/doc_comments/expect_warning_capability_binding_missing_from_payload.subm diff --git a/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm b/crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm rename to crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_capability_tag.subm diff --git a/crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm b/crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm rename to crates/interpreter/tests/fixtures/doc_comments/expect_warning_missing_param_doc.subm diff --git a/crates/submilli-engine/tests/fixtures/duplicate_parameter_names.ts b/crates/interpreter/tests/fixtures/duplicate_parameter_names.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/duplicate_parameter_names.ts rename to crates/interpreter/tests/fixtures/duplicate_parameter_names.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_basic.ts b/crates/interpreter/tests/fixtures/embedding_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_basic.ts rename to crates/interpreter/tests/fixtures/embedding_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_bounds.ts b/crates/interpreter/tests/fixtures/embedding_bounds.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_bounds.ts rename to crates/interpreter/tests/fixtures/embedding_bounds.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_budget_per_run.ts b/crates/interpreter/tests/fixtures/embedding_budget_per_run.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_budget_per_run.ts rename to crates/interpreter/tests/fixtures/embedding_budget_per_run.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_denied.ts b/crates/interpreter/tests/fixtures/embedding_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_denied.ts rename to crates/interpreter/tests/fixtures/embedding_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_error_taxonomy.ts b/crates/interpreter/tests/fixtures/embedding_error_taxonomy.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_error_taxonomy.ts rename to crates/interpreter/tests/fixtures/embedding_error_taxonomy.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_input_too_long.ts b/crates/interpreter/tests/fixtures/embedding_input_too_long.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_input_too_long.ts rename to crates/interpreter/tests/fixtures/embedding_input_too_long.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_models.ts b/crates/interpreter/tests/fixtures/embedding_models.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_models.ts rename to crates/interpreter/tests/fixtures/embedding_models.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_models_filtered.ts b/crates/interpreter/tests/fixtures/embedding_models_filtered.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_models_filtered.ts rename to crates/interpreter/tests/fixtures/embedding_models_filtered.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_no_provider.ts b/crates/interpreter/tests/fixtures/embedding_no_provider.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_no_provider.ts rename to crates/interpreter/tests/fixtures/embedding_no_provider.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_purpose_invalid.ts b/crates/interpreter/tests/fixtures/embedding_purpose_invalid.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_purpose_invalid.ts rename to crates/interpreter/tests/fixtures/embedding_purpose_invalid.ts diff --git a/crates/submilli-engine/tests/fixtures/embedding_unknown_alias.ts b/crates/interpreter/tests/fixtures/embedding_unknown_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/embedding_unknown_alias.ts rename to crates/interpreter/tests/fixtures/embedding_unknown_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/emitter_fallible_healthy.ts b/crates/interpreter/tests/fixtures/emitter_fallible_healthy.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/emitter_fallible_healthy.ts rename to crates/interpreter/tests/fixtures/emitter_fallible_healthy.ts diff --git a/crates/submilli-engine/tests/fixtures/emitter_state_healthy.ts b/crates/interpreter/tests/fixtures/emitter_state_healthy.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/emitter_state_healthy.ts rename to crates/interpreter/tests/fixtures/emitter_state_healthy.ts diff --git a/crates/submilli-engine/tests/fixtures/empty_array_cast.ts b/crates/interpreter/tests/fixtures/empty_array_cast.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/empty_array_cast.ts rename to crates/interpreter/tests/fixtures/empty_array_cast.ts diff --git a/crates/submilli-engine/tests/fixtures/empty_array_cast_non_array.ts b/crates/interpreter/tests/fixtures/empty_array_cast_non_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/empty_array_cast_non_array.ts rename to crates/interpreter/tests/fixtures/empty_array_cast_non_array.ts diff --git a/crates/submilli-engine/tests/fixtures/empty_array_never.ts b/crates/interpreter/tests/fixtures/empty_array_never.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/empty_array_never.ts rename to crates/interpreter/tests/fixtures/empty_array_never.ts diff --git a/crates/submilli-engine/tests/fixtures/enum_member_cases_match_their_own_enum.ts b/crates/interpreter/tests/fixtures/enum_member_cases_match_their_own_enum.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/enum_member_cases_match_their_own_enum.ts rename to crates/interpreter/tests/fixtures/enum_member_cases_match_their_own_enum.ts diff --git a/crates/submilli-engine/tests/fixtures/enum_member_comparison_narrows.ts b/crates/interpreter/tests/fixtures/enum_member_comparison_narrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/enum_member_comparison_narrows.ts rename to crates/interpreter/tests/fixtures/enum_member_comparison_narrows.ts diff --git a/crates/submilli-engine/tests/fixtures/enum_member_types.ts b/crates/interpreter/tests/fixtures/enum_member_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/enum_member_types.ts rename to crates/interpreter/tests/fixtures/enum_member_types.ts diff --git a/crates/submilli-engine/tests/fixtures/enum_negative_zero_initializer.ts b/crates/interpreter/tests/fixtures/enum_negative_zero_initializer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/enum_negative_zero_initializer.ts rename to crates/interpreter/tests/fixtures/enum_negative_zero_initializer.ts diff --git a/crates/submilli-engine/tests/fixtures/enums/enum_decl_numeric_typechecks.subm b/crates/interpreter/tests/fixtures/enums/enum_decl_numeric_typechecks.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/enum_decl_numeric_typechecks.subm rename to crates/interpreter/tests/fixtures/enums/enum_decl_numeric_typechecks.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/enum_decl_string_typechecks.subm b/crates/interpreter/tests/fixtures/enums/enum_decl_string_typechecks.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/enum_decl_string_typechecks.subm rename to crates/interpreter/tests/fixtures/enums/enum_decl_string_typechecks.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/enum_runtime_numeric.subm b/crates/interpreter/tests/fixtures/enums/enum_runtime_numeric.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/enum_runtime_numeric.subm rename to crates/interpreter/tests/fixtures/enums/enum_runtime_numeric.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/enum_runtime_string.subm b/crates/interpreter/tests/fixtures/enums/enum_runtime_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/enum_runtime_string.subm rename to crates/interpreter/tests/fixtures/enums/enum_runtime_string.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_as_value.subm b/crates/interpreter/tests/fixtures/enums/expect_error_enum_as_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/expect_error_enum_as_value.subm rename to crates/interpreter/tests/fixtures/enums/expect_error_enum_as_value.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm b/crates/interpreter/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm rename to crates/interpreter/tests/fixtures/enums/expect_error_enum_mixed_kinds.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_string_missing_value.subm b/crates/interpreter/tests/fixtures/enums/expect_error_enum_string_missing_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/expect_error_enum_string_missing_value.subm rename to crates/interpreter/tests/fixtures/enums/expect_error_enum_string_missing_value.subm diff --git a/crates/submilli-engine/tests/fixtures/enums/expect_error_enum_unknown_variant.subm b/crates/interpreter/tests/fixtures/enums/expect_error_enum_unknown_variant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/enums/expect_error_enum_unknown_variant.subm rename to crates/interpreter/tests/fixtures/enums/expect_error_enum_unknown_variant.subm diff --git a/crates/submilli-engine/tests/fixtures/equality_comparable_operands.ts b/crates/interpreter/tests/fixtures/equality_comparable_operands.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/equality_comparable_operands.ts rename to crates/interpreter/tests/fixtures/equality_comparable_operands.ts diff --git a/crates/submilli-engine/tests/fixtures/equality_literal_operands.ts b/crates/interpreter/tests/fixtures/equality_literal_operands.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/equality_literal_operands.ts rename to crates/interpreter/tests/fixtures/equality_literal_operands.ts diff --git a/crates/submilli-engine/tests/fixtures/error_constructor_default_message.ts b/crates/interpreter/tests/fixtures/error_constructor_default_message.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/error_constructor_default_message.ts rename to crates/interpreter/tests/fixtures/error_constructor_default_message.ts diff --git a/crates/submilli-engine/tests/fixtures/error_is_error.subm b/crates/interpreter/tests/fixtures/error_is_error.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/error_is_error.subm rename to crates/interpreter/tests/fixtures/error_is_error.subm diff --git a/crates/submilli-engine/tests/fixtures/error_is_error_nominal.ts b/crates/interpreter/tests/fixtures/error_is_error_nominal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/error_is_error_nominal.ts rename to crates/interpreter/tests/fixtures/error_is_error_nominal.ts diff --git a/crates/submilli-engine/tests/fixtures/error_subclass_object_keys.ts b/crates/interpreter/tests/fixtures/error_subclass_object_keys.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/error_subclass_object_keys.ts rename to crates/interpreter/tests/fixtures/error_subclass_object_keys.ts diff --git a/crates/submilli-engine/tests/fixtures/error_subclass_to_string.ts b/crates/interpreter/tests/fixtures/error_subclass_to_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/error_subclass_to_string.ts rename to crates/interpreter/tests/fixtures/error_subclass_to_string.ts diff --git a/crates/submilli-engine/tests/fixtures/errors/call_sig_duplicate.subm b/crates/interpreter/tests/fixtures/errors/call_sig_duplicate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/call_sig_duplicate.subm rename to crates/interpreter/tests/fixtures/errors/call_sig_duplicate.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/call_sig_not_callable.subm b/crates/interpreter/tests/fixtures/errors/call_sig_not_callable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/call_sig_not_callable.subm rename to crates/interpreter/tests/fixtures/errors/call_sig_not_callable.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/default_param_in_fn_type.subm b/crates/interpreter/tests/fixtures/errors/default_param_in_fn_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/default_param_in_fn_type.subm rename to crates/interpreter/tests/fixtures/errors/default_param_in_fn_type.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/default_param_type_mismatch.subm b/crates/interpreter/tests/fixtures/errors/default_param_type_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/default_param_type_mismatch.subm rename to crates/interpreter/tests/fixtures/errors/default_param_type_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm b/crates/interpreter/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm rename to crates/interpreter/tests/fixtures/errors/expect_error_reserved_keyword_binding.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/issue_918_partial_catalog.ts b/crates/interpreter/tests/fixtures/errors/issue_918_partial_catalog.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/issue_918_partial_catalog.ts rename to crates/interpreter/tests/fixtures/errors/issue_918_partial_catalog.ts diff --git a/crates/submilli-engine/tests/fixtures/errors/new_no_constructor.subm b/crates/interpreter/tests/fixtures/errors/new_no_constructor.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/new_no_constructor.subm rename to crates/interpreter/tests/fixtures/errors/new_no_constructor.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/new_no_parens.subm b/crates/interpreter/tests/fixtures/errors/new_no_parens.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/new_no_parens.subm rename to crates/interpreter/tests/fixtures/errors/new_no_parens.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/postfix_inc_chain.subm b/crates/interpreter/tests/fixtures/errors/postfix_inc_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/postfix_inc_chain.subm rename to crates/interpreter/tests/fixtures/errors/postfix_inc_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/postfix_inc_const.subm b/crates/interpreter/tests/fixtures/errors/postfix_inc_const.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/postfix_inc_const.subm rename to crates/interpreter/tests/fixtures/errors/postfix_inc_const.subm diff --git a/crates/submilli-engine/tests/fixtures/errors/postfix_inc_non_numeric.subm b/crates/interpreter/tests/fixtures/errors/postfix_inc_non_numeric.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/errors/postfix_inc_non_numeric.subm rename to crates/interpreter/tests/fixtures/errors/postfix_inc_non_numeric.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/break_outside_finally_scope.subm b/crates/interpreter/tests/fixtures/exceptions/break_outside_finally_scope.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/break_outside_finally_scope.subm rename to crates/interpreter/tests/fixtures/exceptions/break_outside_finally_scope.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/catch_binding_reassign.ts b/crates/interpreter/tests/fixtures/exceptions/catch_binding_reassign.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/catch_binding_reassign.ts rename to crates/interpreter/tests/fixtures/exceptions/catch_binding_reassign.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/catch_bindingless.ts b/crates/interpreter/tests/fixtures/exceptions/catch_bindingless.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/catch_bindingless.ts rename to crates/interpreter/tests/fixtures/exceptions/catch_bindingless.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm b/crates/interpreter/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm rename to crates/interpreter/tests/fixtures/exceptions/catch_runs_only_when_thrown.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/catch_unknown.ts b/crates/interpreter/tests/fixtures/exceptions/catch_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/catch_unknown.ts rename to crates/interpreter/tests/fixtures/exceptions/catch_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/catch_untyped_binds_error.ts b/crates/interpreter/tests/fixtures/exceptions/catch_untyped_binds_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/catch_untyped_binds_error.ts rename to crates/interpreter/tests/fixtures/exceptions/catch_untyped_binds_error.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm b/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm rename to crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_advances_for_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm b/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm rename to crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_for_of.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm b/crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm rename to crates/interpreter/tests/fixtures/exceptions/continue_in_try_finally_ordering.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/deep_finally_transfers.ts b/crates/interpreter/tests/fixtures/exceptions/deep_finally_transfers.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/deep_finally_transfers.ts rename to crates/interpreter/tests/fixtures/exceptions/deep_finally_transfers.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/error_default_name.subm b/crates/interpreter/tests/fixtures/exceptions/error_default_name.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/error_default_name.subm rename to crates/interpreter/tests/fixtures/exceptions/error_default_name.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_throw.subm b/crates/interpreter/tests/fixtures/exceptions/expect_error_bare_throw.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_throw.subm rename to crates/interpreter/tests/fixtures/exceptions/expect_error_bare_throw.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_try.subm b/crates/interpreter/tests/fixtures/exceptions/expect_error_bare_try.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_bare_try.subm rename to crates/interpreter/tests/fixtures/exceptions/expect_error_bare_try.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_bindingless_catch_order.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_any_binding.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_any_binding.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_any_binding.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_catch_any_binding.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_catch_binding_reassign_non_error.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm b/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm rename to crates/interpreter/tests/fixtures/exceptions/expect_error_catch_non_error_type.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_duplicate.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_catch_unknown_order.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_after_catch_all.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_duplicate_class.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts b/crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts rename to crates/interpreter/tests/fixtures/exceptions/expect_error_multi_catch_general_before_specific.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/expect_error_throw_non_error.subm b/crates/interpreter/tests/fixtures/exceptions/expect_error_throw_non_error.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/expect_error_throw_non_error.subm rename to crates/interpreter/tests/fixtures/exceptions/expect_error_throw_non_error.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_caught_path.subm b/crates/interpreter/tests/fixtures/exceptions/finally_caught_path.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_caught_path.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_caught_path.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm b/crates/interpreter/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_no_return_preserves_catch_rethrow.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_normal_path.subm b/crates/interpreter/tests/fixtures/exceptions/finally_normal_path.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_normal_path.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_normal_path.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_preserves_pending_completion.ts b/crates/interpreter/tests/fixtures/exceptions/finally_preserves_pending_completion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_preserves_pending_completion.ts rename to crates/interpreter/tests/fixtures/exceptions/finally_preserves_pending_completion.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm b/crates/interpreter/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_return_suppresses_catch_rethrow.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_break.subm b/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_break.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_runs_on_break.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_continue.subm b/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_continue.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_continue.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_runs_on_continue.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return.subm b/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm b/crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_runs_on_return_in_catch.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_transfer_runs_once.ts b/crates/interpreter/tests/fixtures/exceptions/finally_transfer_runs_once.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_transfer_runs_once.ts rename to crates/interpreter/tests/fixtures/exceptions/finally_transfer_runs_once.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/finally_with_own_return_wins.subm b/crates/interpreter/tests/fixtures/exceptions/finally_with_own_return_wins.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/finally_with_own_return_wins.subm rename to crates/interpreter/tests/fixtures/exceptions/finally_with_own_return_wins.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_conditional_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_fallthrough_general.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_finally_every_arm.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_first_match.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_first_match.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_first_match.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_first_match.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_return_in_arm_runs_finally.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_subclass_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_throw_in_arm_runs_finally.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts b/crates/interpreter/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts rename to crates/interpreter/tests/fixtures/exceptions/multi_catch_unmatched_rethrows.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/nested_finally_on_return.subm b/crates/interpreter/tests/fixtures/exceptions/nested_finally_on_return.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/nested_finally_on_return.subm rename to crates/interpreter/tests/fixtures/exceptions/nested_finally_on_return.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/nested_try.subm b/crates/interpreter/tests/fixtures/exceptions/nested_try.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/nested_try.subm rename to crates/interpreter/tests/fixtures/exceptions/nested_try.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/nested_try_finally_break.subm b/crates/interpreter/tests/fixtures/exceptions/nested_try_finally_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/nested_try_finally_break.subm rename to crates/interpreter/tests/fixtures/exceptions/nested_try_finally_break.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/return_in_finally_continues_outward.ts b/crates/interpreter/tests/fixtures/exceptions/return_in_finally_continues_outward.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/return_in_finally_continues_outward.ts rename to crates/interpreter/tests/fixtures/exceptions/return_in_finally_continues_outward.ts diff --git a/crates/submilli-engine/tests/fixtures/exceptions/throw_caught.subm b/crates/interpreter/tests/fixtures/exceptions/throw_caught.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/throw_caught.subm rename to crates/interpreter/tests/fixtures/exceptions/throw_caught.subm diff --git a/crates/submilli-engine/tests/fixtures/exceptions/throw_in_function_caught_outside.subm b/crates/interpreter/tests/fixtures/exceptions/throw_in_function_caught_outside.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/exceptions/throw_in_function_caught_outside.subm rename to crates/interpreter/tests/fixtures/exceptions/throw_in_function_caught_outside.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts b/crates/interpreter/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts rename to crates/interpreter/tests/fixtures/expect_error_accessor_skipped_by_duplicate.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_annotated_callback_conflict.ts b/crates/interpreter/tests/fixtures/expect_error_annotated_callback_conflict.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_annotated_callback_conflict.ts rename to crates/interpreter/tests/fixtures/expect_error_annotated_callback_conflict.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_annotated_destructuring_default.ts b/crates/interpreter/tests/fixtures/expect_error_annotated_destructuring_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_annotated_destructuring_default.ts rename to crates/interpreter/tests/fixtures/expect_error_annotated_destructuring_default.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_annotated_for_of_default.ts b/crates/interpreter/tests/fixtures/expect_error_annotated_for_of_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_annotated_for_of_default.ts rename to crates/interpreter/tests/fixtures/expect_error_annotated_for_of_default.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_element_type.ts b/crates/interpreter/tests/fixtures/expect_error_array_from_array_like_element_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_element_type.ts rename to crates/interpreter/tests/fixtures/expect_error_array_from_array_like_element_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_without_callback.ts b/crates/interpreter/tests/fixtures/expect_error_array_from_array_like_without_callback.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_from_array_like_without_callback.ts rename to crates/interpreter/tests/fixtures/expect_error_array_from_array_like_without_callback.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_from_interface_array_like.ts b/crates/interpreter/tests/fixtures/expect_error_array_from_interface_array_like.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_from_interface_array_like.ts rename to crates/interpreter/tests/fixtures/expect_error_array_from_interface_array_like.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_from_keyed_array_like.subm b/crates/interpreter/tests/fixtures/expect_error_array_from_keyed_array_like.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_from_keyed_array_like.subm rename to crates/interpreter/tests/fixtures/expect_error_array_from_keyed_array_like.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts b/crates/interpreter/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts rename to crates/interpreter/tests/fixtures/expect_error_array_keeps_regular_literal_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_array_type_after_line_break.ts b/crates/interpreter/tests/fixtures/expect_error_array_type_after_line_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_array_type_after_line_break.ts rename to crates/interpreter/tests/fixtures/expect_error_array_type_after_line_break.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_arrow_body_and_signature.ts b/crates/interpreter/tests/fixtures/expect_error_arrow_body_and_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_arrow_body_and_signature.ts rename to crates/interpreter/tests/fixtures/expect_error_arrow_body_and_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_assignment_expression_to_const.ts b/crates/interpreter/tests/fixtures/expect_error_assignment_expression_to_const.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_assignment_expression_to_const.ts rename to crates/interpreter/tests/fixtures/expect_error_assignment_expression_to_const.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_assignment_reported_once.ts b/crates/interpreter/tests/fixtures/expect_error_assignment_reported_once.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_assignment_reported_once.ts rename to crates/interpreter/tests/fixtures/expect_error_assignment_reported_once.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_bigint_literal_type_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_boolean_literal_type_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_braceless_declaration_body.ts b/crates/interpreter/tests/fixtures/expect_error_braceless_declaration_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_braceless_declaration_body.ts rename to crates/interpreter/tests/fixtures/expect_error_braceless_declaration_body.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_braceless_declarations.ts b/crates/interpreter/tests/fixtures/expect_error_braceless_declarations.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_braceless_declarations.ts rename to crates/interpreter/tests/fixtures/expect_error_braceless_declarations.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_break_in_nested_function.ts b/crates/interpreter/tests/fixtures/expect_error_break_in_nested_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_break_in_nested_function.ts rename to crates/interpreter/tests/fixtures/expect_error_break_in_nested_function.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_callback_param_type.ts b/crates/interpreter/tests/fixtures/expect_error_callback_param_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_callback_param_type.ts rename to crates/interpreter/tests/fixtures/expect_error_callback_param_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_callback_return_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_callback_return_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_callback_return_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_callback_return_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_callback_too_many_params.ts b/crates/interpreter/tests/fixtures/expect_error_callback_too_many_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_callback_too_many_params.ts rename to crates/interpreter/tests/fixtures/expect_error_callback_too_many_params.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_callback_untyped_extra_param.ts b/crates/interpreter/tests/fixtures/expect_error_callback_untyped_extra_param.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_callback_untyped_extra_param.ts rename to crates/interpreter/tests/fixtures/expect_error_callback_untyped_extra_param.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_cast_union_without_member_overlap.ts b/crates/interpreter/tests/fixtures/expect_error_cast_union_without_member_overlap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_cast_union_without_member_overlap.ts rename to crates/interpreter/tests/fixtures/expect_error_cast_union_without_member_overlap.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_class_chain_limit.ts b/crates/interpreter/tests/fixtures/expect_error_class_chain_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_class_chain_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_class_chain_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_class_in_function.ts b/crates/interpreter/tests/fixtures/expect_error_class_in_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_class_in_function.ts rename to crates/interpreter/tests/fixtures/expect_error_class_in_function.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_comparable_function_properties.ts b/crates/interpreter/tests/fixtures/expect_error_comparable_function_properties.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_comparable_function_properties.ts rename to crates/interpreter/tests/fixtures/expect_error_comparable_function_properties.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_comparison_never_true.ts b/crates/interpreter/tests/fixtures/expect_error_comparison_never_true.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_comparison_never_true.ts rename to crates/interpreter/tests/fixtures/expect_error_comparison_never_true.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_compound_write_reads_base_type.ts b/crates/interpreter/tests/fixtures/expect_error_compound_write_reads_base_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_compound_write_reads_base_type.ts rename to crates/interpreter/tests/fixtures/expect_error_compound_write_reads_base_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_condition_write_after_narrowing.ts b/crates/interpreter/tests/fixtures/expect_error_condition_write_after_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_condition_write_after_narrowing.ts rename to crates/interpreter/tests/fixtures/expect_error_condition_write_after_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts b/crates/interpreter/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts rename to crates/interpreter/tests/fixtures/expect_error_conditional_assignment_keeps_declared_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_const_literal_operators_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_const_literal_operators_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_const_literal_operators_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_const_literal_operators_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_const_literal_union_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_const_literal_union_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_const_literal_union_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_const_literal_union_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts b/crates/interpreter/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts rename to crates/interpreter/tests/fixtures/expect_error_constant_key_write_ends_field_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_date_constructor.subm b/crates/interpreter/tests/fixtures/expect_error_date_constructor.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_date_constructor.subm rename to crates/interpreter/tests/fixtures/expect_error_date_constructor.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_date_now.subm b/crates/interpreter/tests/fixtures/expect_error_date_now.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_date_now.subm rename to crates/interpreter/tests/fixtures/expect_error_date_now.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_date_type.subm b/crates/interpreter/tests/fixtures/expect_error_date_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_date_type.subm rename to crates/interpreter/tests/fixtures/expect_error_date_type.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_before_required_arity.ts b/crates/interpreter/tests/fixtures/expect_error_default_parameter_before_required_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_default_parameter_before_required_arity.ts rename to crates/interpreter/tests/fixtures/expect_error_default_parameter_before_required_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_iife_tdz.ts b/crates/interpreter/tests/fixtures/expect_error_default_parameter_iife_tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_default_parameter_iife_tdz.ts rename to crates/interpreter/tests/fixtures/expect_error_default_parameter_iife_tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_default_parameter_invalid_write.ts b/crates/interpreter/tests/fixtures/expect_error_default_parameter_invalid_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_default_parameter_invalid_write.ts rename to crates/interpreter/tests/fixtures/expect_error_default_parameter_invalid_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_defaulted_before_required_signature.ts b/crates/interpreter/tests/fixtures/expect_error_defaulted_before_required_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_defaulted_before_required_signature.ts rename to crates/interpreter/tests/fixtures/expect_error_defaulted_before_required_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_delete_unsupported.ts b/crates/interpreter/tests/fixtures/expect_error_delete_unsupported.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_delete_unsupported.ts rename to crates/interpreter/tests/fixtures/expect_error_delete_unsupported.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_destructuring_flow_reset.ts b/crates/interpreter/tests/fixtures/expect_error_destructuring_flow_reset.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_destructuring_flow_reset.ts rename to crates/interpreter/tests/fixtures/expect_error_destructuring_flow_reset.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_destructuring_source_flow_type.ts b/crates/interpreter/tests/fixtures/expect_error_destructuring_source_flow_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_destructuring_source_flow_type.ts rename to crates/interpreter/tests/fixtures/expect_error_destructuring_source_flow_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts b/crates/interpreter/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts rename to crates/interpreter/tests/fixtures/expect_error_discriminant_default_keeps_comparable_member.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_do_while_condition_write.ts b/crates/interpreter/tests/fixtures/expect_error_do_while_condition_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_do_while_condition_write.ts rename to crates/interpreter/tests/fixtures/expect_error_do_while_condition_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_duplicate_type_parameter.ts b/crates/interpreter/tests/fixtures/expect_error_duplicate_type_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_duplicate_type_parameter.ts rename to crates/interpreter/tests/fixtures/expect_error_duplicate_type_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_empty_array_evolving.ts b/crates/interpreter/tests/fixtures/expect_error_empty_array_evolving.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_empty_array_evolving.ts rename to crates/interpreter/tests/fixtures/expect_error_empty_array_evolving.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_enum_member_type_mismatch.ts b/crates/interpreter/tests/fixtures/expect_error_enum_member_type_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_enum_member_type_mismatch.ts rename to crates/interpreter/tests/fixtures/expect_error_enum_member_type_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts b/crates/interpreter/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts rename to crates/interpreter/tests/fixtures/expect_error_enum_switch_on_bare_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_equality_no_overlap.ts b/crates/interpreter/tests/fixtures/expect_error_equality_no_overlap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_equality_no_overlap.ts rename to crates/interpreter/tests/fixtures/expect_error_equality_no_overlap.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_error_new_method.ts b/crates/interpreter/tests/fixtures/expect_error_error_new_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_error_new_method.ts rename to crates/interpreter/tests/fixtures/expect_error_error_new_method.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts b/crates/interpreter/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts rename to crates/interpreter/tests/fixtures/expect_error_exhaustive_switch_leaves_never.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_asserted.ts b/crates/interpreter/tests/fixtures/expect_error_exponentiation_asserted.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exponentiation_asserted.ts rename to crates/interpreter/tests/fixtures/expect_error_exponentiation_asserted.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_not.ts b/crates/interpreter/tests/fixtures/expect_error_exponentiation_not.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exponentiation_not.ts rename to crates/interpreter/tests/fixtures/expect_error_exponentiation_not.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_plus.ts b/crates/interpreter/tests/fixtures/expect_error_exponentiation_plus.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exponentiation_plus.ts rename to crates/interpreter/tests/fixtures/expect_error_exponentiation_plus.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_typeof.ts b/crates/interpreter/tests/fixtures/expect_error_exponentiation_typeof.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exponentiation_typeof.ts rename to crates/interpreter/tests/fixtures/expect_error_exponentiation_typeof.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_exponentiation_unary.ts b/crates/interpreter/tests/fixtures/expect_error_exponentiation_unary.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_exponentiation_unary.ts rename to crates/interpreter/tests/fixtures/expect_error_exponentiation_unary.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_field_does_not_exist.subm b/crates/interpreter/tests/fixtures/expect_error_field_does_not_exist.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_field_does_not_exist.subm rename to crates/interpreter/tests/fixtures/expect_error_field_does_not_exist.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_arg_contravariant.ts b/crates/interpreter/tests/fixtures/expect_error_generic_arg_contravariant.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_arg_contravariant.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_arg_contravariant.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_arg_supertype.ts b/crates/interpreter/tests/fixtures/expect_error_generic_arg_supertype.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_arg_supertype.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_arg_supertype.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_argument_order.ts b/crates/interpreter/tests/fixtures/expect_error_generic_argument_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_argument_order.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_argument_order.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_method_argument_order.ts b/crates/interpreter/tests/fixtures/expect_error_generic_method_argument_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_method_argument_order.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_method_argument_order.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_type_argument_variance.ts b/crates/interpreter/tests/fixtures/expect_error_generic_type_argument_variance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_type_argument_variance.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_type_argument_variance.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_generic_type_size_limit.ts b/crates/interpreter/tests/fixtures/expect_error_generic_type_size_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_generic_type_size_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_generic_type_size_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_getter_needs_return.ts b/crates/interpreter/tests/fixtures/expect_error_getter_needs_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_getter_needs_return.ts rename to crates/interpreter/tests/fixtures/expect_error_getter_needs_return.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_getter_without_return_type.ts b/crates/interpreter/tests/fixtures/expect_error_getter_without_return_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_getter_without_return_type.ts rename to crates/interpreter/tests/fixtures/expect_error_getter_without_return_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_if_empty_body.ts b/crates/interpreter/tests/fixtures/expect_error_if_empty_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_if_empty_body.ts rename to crates/interpreter/tests/fixtures/expect_error_if_empty_body.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts b/crates/interpreter/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts rename to crates/interpreter/tests/fixtures/expect_error_inferred_closure_return_is_widest.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts b/crates/interpreter/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts rename to crates/interpreter/tests/fixtures/expect_error_inferred_closure_returns_without_a_covering_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_unknown_field.ts b/crates/interpreter/tests/fixtures/expect_error_inferred_literal_unknown_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_unknown_field.ts rename to crates/interpreter/tests/fixtures/expect_error_inferred_literal_unknown_field.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_weak_type.ts b/crates/interpreter/tests/fixtures/expect_error_inferred_literal_weak_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_inferred_literal_weak_type.ts rename to crates/interpreter/tests/fixtures/expect_error_inferred_literal_weak_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_inferred_type_depth_limit.ts b/crates/interpreter/tests/fixtures/expect_error_inferred_type_depth_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_inferred_type_depth_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_inferred_type_depth_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_initializer_captured_mutation.ts b/crates/interpreter/tests/fixtures/expect_error_initializer_captured_mutation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_initializer_captured_mutation.ts rename to crates/interpreter/tests/fixtures/expect_error_initializer_captured_mutation.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_initializer_null.ts b/crates/interpreter/tests/fixtures/expect_error_initializer_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_initializer_null.ts rename to crates/interpreter/tests/fixtures/expect_error_initializer_null.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_initializer_readonly.ts b/crates/interpreter/tests/fixtures/expect_error_initializer_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_initializer_readonly.ts rename to crates/interpreter/tests/fixtures/expect_error_initializer_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_property.ts b/crates/interpreter/tests/fixtures/expect_error_interface_to_string_property.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_property.ts rename to crates/interpreter/tests/fixtures/expect_error_interface_to_string_property.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_signature.ts b/crates/interpreter/tests/fixtures/expect_error_interface_to_string_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_interface_to_string_signature.ts rename to crates/interpreter/tests/fixtures/expect_error_interface_to_string_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_annotation_error_beside_initializer_error.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_const_assigned.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_const_assigned.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_const_assigned.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_const_assigned.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_namespace_read_directly.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_namespace_read_directly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_namespace_read_directly.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_namespace_read_directly.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_variable_annotation_names_later_value.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_inferred_type.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_variable_inferred_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_inferred_type.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_variable_inferred_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_read_directly.ts b/crates/interpreter/tests/fixtures/expect_error_later_module_variable_read_directly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_later_module_variable_read_directly.ts rename to crates/interpreter/tests/fixtures/expect_error_later_module_variable_read_directly.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_leading_zero_decimal.ts b/crates/interpreter/tests/fixtures/expect_error_leading_zero_decimal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_leading_zero_decimal.ts rename to crates/interpreter/tests/fixtures/expect_error_leading_zero_decimal.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_legacy_octal_literal.ts b/crates/interpreter/tests/fixtures/expect_error_legacy_octal_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_legacy_octal_literal.ts rename to crates/interpreter/tests/fixtures/expect_error_legacy_octal_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts b/crates/interpreter/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts rename to crates/interpreter/tests/fixtures/expect_error_let_keeps_regular_literal_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_literal_type_number_mismatch.subm b/crates/interpreter/tests/fixtures/expect_error_literal_type_number_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_literal_type_number_mismatch.subm rename to crates/interpreter/tests/fixtures/expect_error_literal_type_number_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_literal_type_string_mismatch.subm b/crates/interpreter/tests/fixtures/expect_error_literal_type_string_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_literal_type_string_mismatch.subm rename to crates/interpreter/tests/fixtures/expect_error_literal_type_string_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm b/crates/interpreter/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm rename to crates/interpreter/tests/fixtures/expect_error_lone_surrogate_literal_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loop_condition_write.ts b/crates/interpreter/tests/fixtures/expect_error_loop_condition_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loop_condition_write.ts rename to crates/interpreter/tests/fixtures/expect_error_loop_condition_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_both_sides.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_both_sides.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_both_sides.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_both_sides.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_constant_results.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_constant_results.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_constant_results.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_constant_results.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_effectful_operand.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_effects_and_lines.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_equality.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_equality.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_parenthesized.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_parenthesized.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_parenthesized.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_parenthesized.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_void.ts b/crates/interpreter/tests/fixtures/expect_error_loose_nullish_void.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_loose_nullish_void.ts rename to crates/interpreter/tests/fixtures/expect_error_loose_nullish_void.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_lt_on_boolean.subm b/crates/interpreter/tests/fixtures/expect_error_lt_on_boolean.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_lt_on_boolean.subm rename to crates/interpreter/tests/fixtures/expect_error_lt_on_boolean.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_map_for_each_param_types.ts b/crates/interpreter/tests/fixtures/expect_error_map_for_each_param_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_map_for_each_param_types.ts rename to crates/interpreter/tests/fixtures/expect_error_map_for_each_param_types.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_name_after_decimal_point.ts b/crates/interpreter/tests/fixtures/expect_error_name_after_decimal_point.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_name_after_decimal_point.ts rename to crates/interpreter/tests/fixtures/expect_error_name_after_decimal_point.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nan_comparison.ts b/crates/interpreter/tests/fixtures/expect_error_nan_comparison.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nan_comparison.ts rename to crates/interpreter/tests/fixtures/expect_error_nan_comparison.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_duplicate.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_duplicate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_duplicate.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_duplicate.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_generic.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_generic.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_missing_return.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_missing_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_missing_return.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_missing_return.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_outer_narrowing.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_outer_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_outer_narrowing.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_outer_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_reads_local_below.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_reads_local_below.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_reads_local_below.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_reads_local_below.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_reassigned.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_reassigned.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_reassigned.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_reassigned.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_shadows_param.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_shadows_param.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_shadows_param.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_shadows_param.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_this.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_this.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_this.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_this.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_capture.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_capture.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_used_before_sibling_reads_local_below.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_through_alias.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_used_through_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_used_through_alias.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_used_through_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nested_function_write_before_capture.ts b/crates/interpreter/tests/fixtures/expect_error_nested_function_write_before_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nested_function_write_before_capture.ts rename to crates/interpreter/tests/fixtures/expect_error_nested_function_write_before_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts b/crates/interpreter/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts rename to crates/interpreter/tests/fixtures/expect_error_never_operand_needs_numeric_partner.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_nullish_mixed_logical.ts b/crates/interpreter/tests/fixtures/expect_error_nullish_mixed_logical.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_nullish_mixed_logical.ts rename to crates/interpreter/tests/fixtures/expect_error_nullish_mixed_logical.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_number_plus_string_help.ts b/crates/interpreter/tests/fixtures/expect_error_number_plus_string_help.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_number_plus_string_help.ts rename to crates/interpreter/tests/fixtures/expect_error_number_plus_string_help.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_numeric_separator.ts b/crates/interpreter/tests/fixtures/expect_error_numeric_separator.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_numeric_separator.ts rename to crates/interpreter/tests/fixtures/expect_error_numeric_separator.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_object_literal_dictionary_union.ts b/crates/interpreter/tests/fixtures/expect_error_object_literal_dictionary_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_object_literal_dictionary_union.ts rename to crates/interpreter/tests/fixtures/expect_error_object_literal_dictionary_union.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_object_rest_const_assign.ts b/crates/interpreter/tests/fixtures/expect_error_object_rest_const_assign.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_object_rest_const_assign.ts rename to crates/interpreter/tests/fixtures/expect_error_object_rest_const_assign.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_object_type_construct_signature.ts b/crates/interpreter/tests/fixtures/expect_error_object_type_construct_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_object_type_construct_signature.ts rename to crates/interpreter/tests/fixtures/expect_error_object_type_construct_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_limit.ts b/crates/interpreter/tests/fixtures/expect_error_optional_chain_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_chain_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_chain_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_missing_key.ts b/crates/interpreter/tests/fixtures/expect_error_optional_chain_missing_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_chain_missing_key.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_chain_missing_key.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_on_namespace.ts b/crates/interpreter/tests/fixtures/expect_error_optional_chain_on_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_chain_on_namespace.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_chain_on_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_chain_write.ts b/crates/interpreter/tests/fixtures/expect_error_optional_chain_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_chain_write.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_chain_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_direct_call.ts b/crates/interpreter/tests/fixtures/expect_error_optional_method_body_direct_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_direct_call.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_method_body_direct_call.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts b/crates/interpreter/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_method_body_receiver_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_method_super_direct_call.ts b/crates/interpreter/tests/fixtures/expect_error_optional_method_super_direct_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_method_super_direct_call.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_method_super_direct_call.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_null_field_into_optional.ts b/crates/interpreter/tests/fixtures/expect_error_optional_null_field_into_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_null_field_into_optional.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_null_field_into_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_optional_parameter_default.ts b/crates/interpreter/tests/fixtures/expect_error_optional_parameter_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_optional_parameter_default.ts rename to crates/interpreter/tests/fixtures/expect_error_optional_parameter_default.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_parameter_modifier_line_break.ts b/crates/interpreter/tests/fixtures/expect_error_parameter_modifier_line_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_parameter_modifier_line_break.ts rename to crates/interpreter/tests/fixtures/expect_error_parameter_modifier_line_break.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_parameterless_index_signature.ts b/crates/interpreter/tests/fixtures/expect_error_parameterless_index_signature.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_parameterless_index_signature.ts rename to crates/interpreter/tests/fixtures/expect_error_parameterless_index_signature.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts b/crates/interpreter/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts rename to crates/interpreter/tests/fixtures/expect_error_parenthesized_non_null_keeps_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_array_for_mutable_type_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_cast_write.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_cast_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_cast_write.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_cast_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_constructor.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_constructor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_constructor.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_constructor.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_class_member.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_line_break_class_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_class_member.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_line_break_class_member.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_type_member.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_line_break_type_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_line_break_type_member.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_line_break_type_member.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_readonly_method.ts b/crates/interpreter/tests/fixtures/expect_error_readonly_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_readonly_method.ts rename to crates/interpreter/tests/fixtures/expect_error_readonly_method.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_backreference.subm b/crates/interpreter/tests/fixtures/expect_error_regex_backreference.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_backreference.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_backreference.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_duplicate_flag.subm b/crates/interpreter/tests/fixtures/expect_error_regex_duplicate_flag.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_duplicate_flag.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_duplicate_flag.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_flag.subm b/crates/interpreter/tests/fixtures/expect_error_regex_invalid_flag.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_flag.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_invalid_flag.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_pattern.subm b/crates/interpreter/tests/fixtures/expect_error_regex_invalid_pattern.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_invalid_pattern.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_invalid_pattern.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_lookahead.subm b/crates/interpreter/tests/fixtures/expect_error_regex_lookahead.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_lookahead.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_lookahead.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_lookbehind.subm b/crates/interpreter/tests/fixtures/expect_error_regex_lookbehind.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_lookbehind.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_lookbehind.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_named_backref.subm b/crates/interpreter/tests/fixtures/expect_error_regex_named_backref.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_named_backref.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_named_backref.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookahead.subm b/crates/interpreter/tests/fixtures/expect_error_regex_negative_lookahead.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookahead.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_negative_lookahead.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookbehind.subm b/crates/interpreter/tests/fixtures/expect_error_regex_negative_lookbehind.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_negative_lookbehind.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_negative_lookbehind.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_regex_unterminated.subm b/crates/interpreter/tests/fixtures/expect_error_regex_unterminated.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_regex_unterminated.subm rename to crates/interpreter/tests/fixtures/expect_error_regex_unterminated.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_required_parameter_after_optional.ts b/crates/interpreter/tests/fixtures/expect_error_required_parameter_after_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_required_parameter_after_optional.ts rename to crates/interpreter/tests/fixtures/expect_error_required_parameter_after_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_arity_too_few.subm b/crates/interpreter/tests/fixtures/expect_error_rest_arity_too_few.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_arity_too_few.subm rename to crates/interpreter/tests/fixtures/expect_error_rest_arity_too_few.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts b/crates/interpreter/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts rename to crates/interpreter/tests/fixtures/expect_error_rest_callback_for_fixed_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_no_annotation.subm b/crates/interpreter/tests/fixtures/expect_error_rest_no_annotation.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_no_annotation.subm rename to crates/interpreter/tests/fixtures/expect_error_rest_no_annotation.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_non_array.subm b/crates/interpreter/tests/fixtures/expect_error_rest_non_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_non_array.subm rename to crates/interpreter/tests/fixtures/expect_error_rest_non_array.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_not_last.subm b/crates/interpreter/tests/fixtures/expect_error_rest_not_last.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_not_last.subm rename to crates/interpreter/tests/fixtures/expect_error_rest_not_last.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_rest_with_default.subm b/crates/interpreter/tests/fixtures/expect_error_rest_with_default.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_rest_with_default.subm rename to crates/interpreter/tests/fixtures/expect_error_rest_with_default.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_runtime_check_limit.ts b/crates/interpreter/tests/fixtures/expect_error_runtime_check_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_runtime_check_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_runtime_check_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_runtime_check_locals_limit.ts b/crates/interpreter/tests/fixtures/expect_error_runtime_check_locals_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_runtime_check_locals_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_runtime_check_locals_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_fallback_limit.ts b/crates/interpreter/tests/fixtures/expect_error_spread_fallback_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_fallback_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_fallback_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_field_mismatches_interface.ts b/crates/interpreter/tests/fixtures/expect_error_spread_field_mismatches_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_field_mismatches_interface.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_field_mismatches_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_null.ts b/crates/interpreter/tests/fixtures/expect_error_spread_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_null.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_null.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts b/crates/interpreter/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_of_conditional_widens_field.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts b/crates/interpreter/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_optional_field_keeps_earlier_type.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_optional_into_required.ts b/crates/interpreter/tests/fixtures/expect_error_spread_optional_into_required.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_optional_into_required.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_optional_into_required.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_overwrites_union_tag.ts b/crates/interpreter/tests/fixtures/expect_error_spread_overwrites_union_tag.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_overwrites_union_tag.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_overwrites_union_tag.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_spread_union_may_be_empty.ts b/crates/interpreter/tests/fixtures/expect_error_spread_union_may_be_empty.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_spread_union_may_be_empty.ts rename to crates/interpreter/tests/fixtures/expect_error_spread_union_may_be_empty.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_strict_mode_reserved_binding.ts b/crates/interpreter/tests/fixtures/expect_error_strict_mode_reserved_binding.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_strict_mode_reserved_binding.ts rename to crates/interpreter/tests/fixtures/expect_error_strict_mode_reserved_binding.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_string_at_unnarrowed.ts b/crates/interpreter/tests/fixtures/expect_error_string_at_unnarrowed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_string_at_unnarrowed.ts rename to crates/interpreter/tests/fixtures/expect_error_string_at_unnarrowed.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_string_or_array_union_method_argument.ts b/crates/interpreter/tests/fixtures/expect_error_string_or_array_union_method_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_string_or_array_union_method_argument.ts rename to crates/interpreter/tests/fixtures/expect_error_string_or_array_union_method_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_string_plus_number_help.ts b/crates/interpreter/tests/fixtures/expect_error_string_plus_number_help.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_string_plus_number_help.ts rename to crates/interpreter/tests/fixtures/expect_error_string_plus_number_help.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_string_unknown_method.subm b/crates/interpreter/tests/fixtures/expect_error_string_unknown_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_string_unknown_method.subm rename to crates/interpreter/tests/fixtures/expect_error_string_unknown_method.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_super_conditional.ts b/crates/interpreter/tests/fixtures/expect_error_super_conditional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_super_conditional.ts rename to crates/interpreter/tests/fixtures/expect_error_super_conditional.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_super_in_function_expression.ts b/crates/interpreter/tests/fixtures/expect_error_super_in_function_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_super_in_function_expression.ts rename to crates/interpreter/tests/fixtures/expect_error_super_in_function_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_super_in_nested_function.ts b/crates/interpreter/tests/fixtures/expect_error_super_in_nested_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_super_in_nested_function.ts rename to crates/interpreter/tests/fixtures/expect_error_super_in_nested_function.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_super_misplaced.ts b/crates/interpreter/tests/fixtures/expect_error_super_misplaced.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_super_misplaced.ts rename to crates/interpreter/tests/fixtures/expect_error_super_misplaced.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_super_reads_before_call.ts b/crates/interpreter/tests/fixtures/expect_error_super_reads_before_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_super_reads_before_call.ts rename to crates/interpreter/tests/fixtures/expect_error_super_reads_before_call.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts b/crates/interpreter/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_case_null_absent_optional_field.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts b/crates/interpreter/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_clause_local_shadows_before_declaration.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts b/crates/interpreter/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_clause_reads_other_clause_local.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_const.ts b/crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_const.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_const.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_const.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_function.ts b/crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_clause_redeclares_function.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_clause_redeclares_function.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts b/crates/interpreter/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_default_reads_before_later_case_declaration.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts b/crates/interpreter/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_function_uses_other_clause_local.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts b/crates/interpreter/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_later_clause_reads_shadowed_name.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts b/crates/interpreter/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_later_clause_writes_shadowed_name.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts b/crates/interpreter/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts rename to crates/interpreter/tests/fixtures/expect_error_switch_namespace_declared_in_another_clause.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_syntax_nesting_limit.ts b/crates/interpreter/tests/fixtures/expect_error_syntax_nesting_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_syntax_nesting_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_syntax_nesting_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_template_nesting_limit.ts b/crates/interpreter/tests/fixtures/expect_error_template_nesting_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_template_nesting_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_template_nesting_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts b/crates/interpreter/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts rename to crates/interpreter/tests/fixtures/expect_error_temporal_duration_positional_ctor.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts b/crates/interpreter/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts rename to crates/interpreter/tests/fixtures/expect_error_temporal_duration_weak_type_number.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_this_in_unbound_function_expression.ts b/crates/interpreter/tests/fixtures/expect_error_this_in_unbound_function_expression.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_this_in_unbound_function_expression.ts rename to crates/interpreter/tests/fixtures/expect_error_this_in_unbound_function_expression.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_signature.subm b/crates/interpreter/tests/fixtures/expect_error_tostring_wrong_signature.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_signature.subm rename to crates/interpreter/tests/fixtures/expect_error_tostring_wrong_signature.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_type.subm b/crates/interpreter/tests/fixtures/expect_error_tostring_wrong_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tostring_wrong_type.subm rename to crates/interpreter/tests/fixtures/expect_error_tostring_wrong_type.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_arity_mismatch.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_arity_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_arity_mismatch.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_arity_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_element_type.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_element_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_element_type.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_element_type.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_empty_rejected.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_empty_rejected.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_empty_rejected.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_empty_rejected.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_index_non_literal.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_index_non_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_index_non_literal.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_index_non_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_index_oob.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_index_oob.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_index_oob.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_index_oob.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_mutators.ts b/crates/interpreter/tests/fixtures/expect_error_tuple_mutators.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_mutators.ts rename to crates/interpreter/tests/fixtures/expect_error_tuple_mutators.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_optional_rest_elements.ts b/crates/interpreter/tests/fixtures/expect_error_tuple_optional_rest_elements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_optional_rest_elements.ts rename to crates/interpreter/tests/fixtures/expect_error_tuple_optional_rest_elements.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_push.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_push.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_push.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_push.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_tuple_sort.subm b/crates/interpreter/tests/fixtures/expect_error_tuple_sort.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_tuple_sort.subm rename to crates/interpreter/tests/fixtures/expect_error_tuple_sort.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_args_after_line_break.ts b/crates/interpreter/tests/fixtures/expect_error_type_args_after_line_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_args_after_line_break.ts rename to crates/interpreter/tests/fixtures/expect_error_type_args_after_line_break.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts b/crates/interpreter/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts rename to crates/interpreter/tests/fixtures/expect_error_type_declaration_named_like_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_mismatch.subm b/crates/interpreter/tests/fixtures/expect_error_type_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_mismatch.subm rename to crates/interpreter/tests/fixtures/expect_error_type_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_nesting_limit.ts b/crates/interpreter/tests/fixtures/expect_error_type_nesting_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_nesting_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_type_nesting_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts b/crates/interpreter/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts rename to crates/interpreter/tests/fixtures/expect_error_type_predicate_not_assignable_to_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_type_size_limit.ts b/crates/interpreter/tests/fixtures/expect_error_type_size_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_type_size_limit.ts rename to crates/interpreter/tests/fixtures/expect_error_type_size_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_typeof_invalid_tag.subm b/crates/interpreter/tests/fixtures/expect_error_typeof_invalid_tag.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_typeof_invalid_tag.subm rename to crates/interpreter/tests/fixtures/expect_error_typeof_invalid_tag.subm diff --git a/crates/submilli-engine/tests/fixtures/expect_error_typeof_of_a_type_name.ts b/crates/interpreter/tests/fixtures/expect_error_typeof_of_a_type_name.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_typeof_of_a_type_name.ts rename to crates/interpreter/tests/fixtures/expect_error_typeof_of_a_type_name.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_typeof_unknown_value.ts b/crates/interpreter/tests/fixtures/expect_error_typeof_unknown_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_typeof_unknown_value.ts rename to crates/interpreter/tests/fixtures/expect_error_typeof_unknown_value.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_unary_minus_string.ts b/crates/interpreter/tests/fixtures/expect_error_unary_minus_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_unary_minus_string.ts rename to crates/interpreter/tests/fixtures/expect_error_unary_minus_string.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_unary_plus_nullable_string.ts b/crates/interpreter/tests/fixtures/expect_error_unary_plus_nullable_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_unary_plus_nullable_string.ts rename to crates/interpreter/tests/fixtures/expect_error_unary_plus_nullable_string.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts b/crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts rename to crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_declaration.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_export.ts b/crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_export.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_unclosed_interface_before_export.ts rename to crates/interpreter/tests/fixtures/expect_error_unclosed_interface_before_export.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts b/crates/interpreter/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts rename to crates/interpreter/tests/fixtures/expect_error_unclosed_type_literal_before_declaration.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts b/crates/interpreter/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts rename to crates/interpreter/tests/fixtures/expect_error_undefined_local_const_pattern_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts b/crates/interpreter/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts rename to crates/interpreter/tests/fixtures/expect_error_undefined_parameter_pattern_literal_write.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts b/crates/interpreter/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts rename to crates/interpreter/tests/fixtures/expect_error_undefined_parameter_property_literal_default.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required.ts b/crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required.ts rename to crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts b/crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts rename to crates/interpreter/tests/fixtures/expect_error_undefined_tuple_spread_required_union.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_union_literal_assignment_only.ts b/crates/interpreter/tests/fixtures/expect_error_union_literal_assignment_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_union_literal_assignment_only.ts rename to crates/interpreter/tests/fixtures/expect_error_union_literal_assignment_only.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field.ts b/crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field.ts rename to crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts b/crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts rename to crates/interpreter/tests/fixtures/expect_error_union_literal_unknown_field_tags.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_visibility_after_readonly.ts b/crates/interpreter/tests/fixtures/expect_error_visibility_after_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_visibility_after_readonly.ts rename to crates/interpreter/tests/fixtures/expect_error_visibility_after_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_void_compared_with_value.ts b/crates/interpreter/tests/fixtures/expect_error_void_compared_with_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_void_compared_with_value.ts rename to crates/interpreter/tests/fixtures/expect_error_void_compared_with_value.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_void_condition.ts b/crates/interpreter/tests/fixtures/expect_error_void_condition.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_void_condition.ts rename to crates/interpreter/tests/fixtures/expect_error_void_condition.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_void_conditional_into_value_slot.ts b/crates/interpreter/tests/fixtures/expect_error_void_conditional_into_value_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_void_conditional_into_value_slot.ts rename to crates/interpreter/tests/fixtures/expect_error_void_conditional_into_value_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts b/crates/interpreter/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts rename to crates/interpreter/tests/fixtures/expect_error_void_parameter_default_keeps_void.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_error_weak_type_no_common_field.ts b/crates/interpreter/tests/fixtures/expect_error_weak_type_no_common_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_error_weak_type_no_common_field.ts rename to crates/interpreter/tests/fixtures/expect_error_weak_type_no_common_field.ts diff --git a/crates/submilli-engine/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts b/crates/interpreter/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts rename to crates/interpreter/tests/fixtures/expect_warning_nullish_non_null_left_keeps_its_type.ts diff --git a/crates/submilli-engine/tests/fixtures/exponentiation_grouping.ts b/crates/interpreter/tests/fixtures/exponentiation_grouping.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/exponentiation_grouping.ts rename to crates/interpreter/tests/fixtures/exponentiation_grouping.ts diff --git a/crates/submilli-engine/tests/fixtures/field_assignment_flow.ts b/crates/interpreter/tests/fixtures/field_assignment_flow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/field_assignment_flow.ts rename to crates/interpreter/tests/fixtures/field_assignment_flow.ts diff --git a/crates/submilli-engine/tests/fixtures/for_of_string_or_array.ts b/crates/interpreter/tests/fixtures/for_of_string_or_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/for_of_string_or_array.ts rename to crates/interpreter/tests/fixtures/for_of_string_or_array.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/absence_probing.ts b/crates/interpreter/tests/fixtures/fs/absence_probing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/absence_probing.ts rename to crates/interpreter/tests/fixtures/fs/absence_probing.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/append_text.subm b/crates/interpreter/tests/fixtures/fs/append_text.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/append_text.subm rename to crates/interpreter/tests/fixtures/fs/append_text.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/bytes_iteration.subm b/crates/interpreter/tests/fixtures/fs/bytes_iteration.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/bytes_iteration.subm rename to crates/interpreter/tests/fixtures/fs/bytes_iteration.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/bytes_write_read.subm b/crates/interpreter/tests/fixtures/fs/bytes_write_read.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/bytes_write_read.subm rename to crates/interpreter/tests/fixtures/fs/bytes_write_read.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/copy_creates_destination_parents.ts b/crates/interpreter/tests/fixtures/fs/copy_creates_destination_parents.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/copy_creates_destination_parents.ts rename to crates/interpreter/tests/fixtures/fs/copy_creates_destination_parents.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/cwd.ts b/crates/interpreter/tests/fixtures/fs/cwd.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/cwd.ts rename to crates/interpreter/tests/fixtures/fs/cwd.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/exists_size.subm b/crates/interpreter/tests/fixtures/fs/exists_size.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/exists_size.subm rename to crates/interpreter/tests/fixtures/fs/exists_size.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/info_basic.subm b/crates/interpreter/tests/fixtures/fs/info_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/info_basic.subm rename to crates/interpreter/tests/fixtures/fs/info_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/linear_remove_move.ts b/crates/interpreter/tests/fixtures/fs/linear_remove_move.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/linear_remove_move.ts rename to crates/interpreter/tests/fixtures/fs/linear_remove_move.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/lines_break.subm b/crates/interpreter/tests/fixtures/fs/lines_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/lines_break.subm rename to crates/interpreter/tests/fixtures/fs/lines_break.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/lines_iteration.subm b/crates/interpreter/tests/fixtures/fs/lines_iteration.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/lines_iteration.subm rename to crates/interpreter/tests/fixtures/fs/lines_iteration.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/list_deep.ts b/crates/interpreter/tests/fixtures/fs/list_deep.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/list_deep.ts rename to crates/interpreter/tests/fixtures/fs/list_deep.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/list_entry_shape.ts b/crates/interpreter/tests/fixtures/fs/list_entry_shape.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/list_entry_shape.ts rename to crates/interpreter/tests/fixtures/fs/list_entry_shape.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/list_flat.subm b/crates/interpreter/tests/fixtures/fs/list_flat.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/list_flat.subm rename to crates/interpreter/tests/fixtures/fs/list_flat.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/list_recursive.subm b/crates/interpreter/tests/fixtures/fs/list_recursive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/list_recursive.subm rename to crates/interpreter/tests/fixtures/fs/list_recursive.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/many_handles_recovered.subm b/crates/interpreter/tests/fixtures/fs/many_handles_recovered.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/many_handles_recovered.subm rename to crates/interpreter/tests/fixtures/fs/many_handles_recovered.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/max_read_size.subm b/crates/interpreter/tests/fixtures/fs/max_read_size.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/max_read_size.subm rename to crates/interpreter/tests/fixtures/fs/max_read_size.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/mkdir_nested.subm b/crates/interpreter/tests/fixtures/fs/mkdir_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/mkdir_nested.subm rename to crates/interpreter/tests/fixtures/fs/mkdir_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/move_copy_remove.subm b/crates/interpreter/tests/fixtures/fs/move_copy_remove.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/move_copy_remove.subm rename to crates/interpreter/tests/fixtures/fs/move_copy_remove.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/peek_basic.subm b/crates/interpreter/tests/fixtures/fs/peek_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/peek_basic.subm rename to crates/interpreter/tests/fixtures/fs/peek_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/peek_crlf.subm b/crates/interpreter/tests/fixtures/fs/peek_crlf.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/peek_crlf.subm rename to crates/interpreter/tests/fixtures/fs/peek_crlf.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/read_bytes_range.subm b/crates/interpreter/tests/fixtures/fs/read_bytes_range.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/read_bytes_range.subm rename to crates/interpreter/tests/fixtures/fs/read_bytes_range.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/remove_recursive.subm b/crates/interpreter/tests/fixtures/fs/remove_recursive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/remove_recursive.subm rename to crates/interpreter/tests/fixtures/fs/remove_recursive.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/root_is_not_a_target.ts b/crates/interpreter/tests/fixtures/fs/root_is_not_a_target.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/root_is_not_a_target.ts rename to crates/interpreter/tests/fixtures/fs/root_is_not_a_target.ts diff --git a/crates/submilli-engine/tests/fixtures/fs/stat_kinds.subm b/crates/interpreter/tests/fixtures/fs/stat_kinds.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/stat_kinds.subm rename to crates/interpreter/tests/fixtures/fs/stat_kinds.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/text_write_read.subm b/crates/interpreter/tests/fixtures/fs/text_write_read.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/text_write_read.subm rename to crates/interpreter/tests/fixtures/fs/text_write_read.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/writer_basic.subm b/crates/interpreter/tests/fixtures/fs/writer_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/writer_basic.subm rename to crates/interpreter/tests/fixtures/fs/writer_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/fs/writer_bytes.subm b/crates/interpreter/tests/fixtures/fs/writer_bytes.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/fs/writer_bytes.subm rename to crates/interpreter/tests/fixtures/fs/writer_bytes.subm diff --git a/crates/submilli-engine/tests/fixtures/function_as_value.subm b/crates/interpreter/tests/fixtures/function_as_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_as_value.subm rename to crates/interpreter/tests/fixtures/function_as_value.subm diff --git a/crates/submilli-engine/tests/fixtures/function_identity_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/function_identity_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_identity_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/function_identity_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/extra.ts b/crates/interpreter/tests/fixtures/function_identity_cross_package/lib/extra.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/extra.ts rename to crates/interpreter/tests/fixtures/function_identity_cross_package/lib/extra.ts diff --git a/crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/function_identity_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_identity_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/function_identity_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/function_identity_cross_package/mid/lib.ts b/crates/interpreter/tests/fixtures/function_identity_cross_package/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_identity_cross_package/mid/lib.ts rename to crates/interpreter/tests/fixtures/function_identity_cross_package/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/function_identity_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/function_identity_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_identity_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/function_identity_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/function_type_rendering_round_trip.ts b/crates/interpreter/tests/fixtures/function_type_rendering_round_trip.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_type_rendering_round_trip.ts rename to crates/interpreter/tests/fixtures/function_type_rendering_round_trip.ts diff --git a/crates/submilli-engine/tests/fixtures/function_type_renders_parseable.ts b/crates/interpreter/tests/fixtures/function_type_renders_parseable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_type_renders_parseable.ts rename to crates/interpreter/tests/fixtures/function_type_renders_parseable.ts diff --git a/crates/submilli-engine/tests/fixtures/function_typed_array_elements.ts b/crates/interpreter/tests/fixtures/function_typed_array_elements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/function_typed_array_elements.ts rename to crates/interpreter/tests/fixtures/function_typed_array_elements.ts diff --git a/crates/submilli-engine/tests/fixtures/generic_arg_accepts_subclass.ts b/crates/interpreter/tests/fixtures/generic_arg_accepts_subclass.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generic_arg_accepts_subclass.ts rename to crates/interpreter/tests/fixtures/generic_arg_accepts_subclass.ts diff --git a/crates/submilli-engine/tests/fixtures/generic_call_infers_common_supertype.ts b/crates/interpreter/tests/fixtures/generic_call_infers_common_supertype.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generic_call_infers_common_supertype.ts rename to crates/interpreter/tests/fixtures/generic_call_infers_common_supertype.ts diff --git a/crates/submilli-engine/tests/fixtures/generic_call_infers_from_expected_union.ts b/crates/interpreter/tests/fixtures/generic_call_infers_from_expected_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generic_call_infers_from_expected_union.ts rename to crates/interpreter/tests/fixtures/generic_call_infers_from_expected_union.ts diff --git a/crates/submilli-engine/tests/fixtures/generic_type_argument_variance.ts b/crates/interpreter/tests/fixtures/generic_type_argument_variance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generic_type_argument_variance.ts rename to crates/interpreter/tests/fixtures/generic_type_argument_variance.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/array_push_aliased_function.subm b/crates/interpreter/tests/fixtures/generics/array_push_aliased_function.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/array_push_aliased_function.subm rename to crates/interpreter/tests/fixtures/generics/array_push_aliased_function.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/array_sort_aliased_object.subm b/crates/interpreter/tests/fixtures/generics/array_sort_aliased_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/array_sort_aliased_object.subm rename to crates/interpreter/tests/fixtures/generics/array_sort_aliased_object.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/call_void_return_type_arg.ts b/crates/interpreter/tests/fixtures/generics/call_void_return_type_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/call_void_return_type_arg.ts rename to crates/interpreter/tests/fixtures/generics/call_void_return_type_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/callback_parameter_wider_than_element.ts b/crates/interpreter/tests/fixtures/generics/callback_parameter_wider_than_element.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/callback_parameter_wider_than_element.ts rename to crates/interpreter/tests/fixtures/generics/callback_parameter_wider_than_element.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/captured_typevar_union_boxed.ts b/crates/interpreter/tests/fixtures/generics/captured_typevar_union_boxed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/captured_typevar_union_boxed.ts rename to crates/interpreter/tests/fixtures/generics/captured_typevar_union_boxed.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_box_basic.ts b/crates/interpreter/tests/fixtures/generics/class_box_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_box_basic.ts rename to crates/interpreter/tests/fixtures/generics/class_box_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_closure_typed_field.ts b/crates/interpreter/tests/fixtures/generics/class_closure_typed_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_closure_typed_field.ts rename to crates/interpreter/tests/fixtures/generics/class_closure_typed_field.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package/boxes/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package/boxes/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package/boxes/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package/boxes/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_chain/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_chain/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_chain/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_chain/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_chain/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_chain/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_closure_member/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_generic_child/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/mid/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_implicit_ctor/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_interface/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_interface/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_interface/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_interface/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_interface/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/app/main.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/app/main.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts b/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts rename to crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/packages.manifest b/crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_cross_package_namespace/packages.manifest rename to crates/interpreter/tests/fixtures/generics/class_cross_package_namespace/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/generics/class_erased_slot_abi.ts b/crates/interpreter/tests/fixtures/generics/class_erased_slot_abi.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_erased_slot_abi.ts rename to crates/interpreter/tests/fixtures/generics/class_erased_slot_abi.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_error_subclass.ts b/crates/interpreter/tests/fixtures/generics/class_error_subclass.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_error_subclass.ts rename to crates/interpreter/tests/fixtures/generics/class_error_subclass.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_extends_concrete_args.ts b/crates/interpreter/tests/fixtures/generics/class_extends_concrete_args.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_extends_concrete_args.ts rename to crates/interpreter/tests/fixtures/generics/class_extends_concrete_args.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_generic_extends_generic.ts b/crates/interpreter/tests/fixtures/generics/class_generic_extends_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_generic_extends_generic.ts rename to crates/interpreter/tests/fixtures/generics/class_generic_extends_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_generic_field_rw.ts b/crates/interpreter/tests/fixtures/generics/class_generic_field_rw.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_generic_field_rw.ts rename to crates/interpreter/tests/fixtures/generics/class_generic_field_rw.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_implements_generic_interface.ts b/crates/interpreter/tests/fixtures/generics/class_implements_generic_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_implements_generic_interface.ts rename to crates/interpreter/tests/fixtures/generics/class_implements_generic_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_infer_void_arg.ts b/crates/interpreter/tests/fixtures/generics/class_infer_void_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_infer_void_arg.ts rename to crates/interpreter/tests/fixtures/generics/class_infer_void_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_instanceof.ts b/crates/interpreter/tests/fixtures/generics/class_instanceof.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_instanceof.ts rename to crates/interpreter/tests/fixtures/generics/class_instanceof.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_instanceof_subclass.ts b/crates/interpreter/tests/fixtures/generics/class_instanceof_subclass.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_instanceof_subclass.ts rename to crates/interpreter/tests/fixtures/generics/class_instanceof_subclass.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_object_literal_in_closure.ts b/crates/interpreter/tests/fixtures/generics/class_object_literal_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_object_literal_in_closure.ts rename to crates/interpreter/tests/fixtures/generics/class_object_literal_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_recursive_node.ts b/crates/interpreter/tests/fixtures/generics/class_recursive_node.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_recursive_node.ts rename to crates/interpreter/tests/fixtures/generics/class_recursive_node.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_statics_optional_readonly.ts b/crates/interpreter/tests/fixtures/generics/class_statics_optional_readonly.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_statics_optional_readonly.ts rename to crates/interpreter/tests/fixtures/generics/class_statics_optional_readonly.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_this_in_closure.ts b/crates/interpreter/tests/fixtures/generics/class_this_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_this_in_closure.ts rename to crates/interpreter/tests/fixtures/generics/class_this_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_two_params.ts b/crates/interpreter/tests/fixtures/generics/class_two_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_two_params.ts rename to crates/interpreter/tests/fixtures/generics/class_two_params.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_type_arg_shapes.ts b/crates/interpreter/tests/fixtures/generics/class_type_arg_shapes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_type_arg_shapes.ts rename to crates/interpreter/tests/fixtures/generics/class_type_arg_shapes.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts b/crates/interpreter/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts rename to crates/interpreter/tests/fixtures/generics/class_uninferred_type_param_is_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_union_narrowing.ts b/crates/interpreter/tests/fixtures/generics/class_union_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_union_narrowing.ts rename to crates/interpreter/tests/fixtures/generics/class_union_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_universal_slots.ts b/crates/interpreter/tests/fixtures/generics/class_universal_slots.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_universal_slots.ts rename to crates/interpreter/tests/fixtures/generics/class_universal_slots.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/class_void_type_arg.ts b/crates/interpreter/tests/fixtures/generics/class_void_type_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/class_void_type_arg.ts rename to crates/interpreter/tests/fixtures/generics/class_void_type_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_arithmetic_on_t.subm b/crates/interpreter/tests/fixtures/generics/expect_error_arithmetic_on_t.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_arithmetic_on_t.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_arithmetic_on_t.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_arity_mismatch.subm b/crates/interpreter/tests/fixtures/generics/expect_error_arity_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_arity_mismatch.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_arity_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts b/crates/interpreter/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_callback_base_class_with_unbound_arguments.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_arg_mismatch.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_arg_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_arg_mismatch.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_arg_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_extends_arity.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_extends_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_extends_arity.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_extends_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_generic_arity.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_generic_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_generic_arity.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_generic_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_implements_wrong_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_alias.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_alias.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_args.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_args.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_args.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_args.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_instanceof_impossible.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_method_generic.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_method_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_method_generic.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_method_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_never_type_arg.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_never_type_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_never_type_arg.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_never_type_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_class_static_type_param.ts b/crates/interpreter/tests/fixtures/generics/expect_error_class_static_type_param.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_class_static_type_param.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_class_static_type_param.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm b/crates/interpreter/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_concrete_into_generic_call.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_conflicting_bindings.subm b/crates/interpreter/tests/fixtures/generics/expect_error_conflicting_bindings.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_conflicting_bindings.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_conflicting_bindings.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_cross_gp_assignment.subm b/crates/interpreter/tests/fixtures/generics/expect_error_cross_gp_assignment.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_cross_gp_assignment.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_cross_gp_assignment.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts b/crates/interpreter/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_ctor_void_type_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_first_class_generic.subm b/crates/interpreter/tests/fixtures/generics/expect_error_first_class_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_first_class_generic.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_first_class_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_call_common_supertype.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_call_keeps_regular_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_method_interface_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_plain_value_keeps_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_object_argument_slot_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_chain_back_to_root.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts b/crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_generic_variance_growing_instantiations.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_inference_argument_priority.ts b/crates/interpreter/tests/fixtures/generics/expect_error_inference_argument_priority.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_inference_argument_priority.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_inference_argument_priority.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_interface_arity.subm b/crates/interpreter/tests/fixtures/generics/expect_error_interface_arity.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_interface_arity.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_interface_arity.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_method_never_type_arg.ts b/crates/interpreter/tests/fixtures/generics/expect_error_method_never_type_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_method_never_type_arg.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_method_never_type_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm b/crates/interpreter/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_recursion_assigns_concrete_to_t.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm b/crates/interpreter/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm rename to crates/interpreter/tests/fixtures/generics/expect_error_recursion_returns_concrete.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts b/crates/interpreter/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_uninferred_type_param_is_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/expect_error_union_member_closely_matched.ts b/crates/interpreter/tests/fixtures/generics/expect_error_union_member_closely_matched.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/expect_error_union_member_closely_matched.ts rename to crates/interpreter/tests/fixtures/generics/expect_error_union_member_closely_matched.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/explicit_type_args.subm b/crates/interpreter/tests/fixtures/generics/explicit_type_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/explicit_type_args.subm rename to crates/interpreter/tests/fixtures/generics/explicit_type_args.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/first.subm b/crates/interpreter/tests/fixtures/generics/first.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/first.subm rename to crates/interpreter/tests/fixtures/generics/first.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts b/crates/interpreter/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_infers_from_nested_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_keeps_literal_type.ts b/crates/interpreter/tests/fixtures/generics/generic_call_keeps_literal_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_keeps_literal_type.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_keeps_literal_type.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts b/crates/interpreter/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_literal_candidates_form_union.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_nested_literal_arguments.ts b/crates/interpreter/tests/fixtures/generics/generic_call_nested_literal_arguments.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_nested_literal_arguments.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_nested_literal_arguments.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts b/crates/interpreter/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_result_keeps_declared_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_call_widens_fresh_literal.ts b/crates/interpreter/tests/fixtures/generics/generic_call_widens_fresh_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_call_widens_fresh_literal.ts rename to crates/interpreter/tests/fixtures/generics/generic_call_widens_fresh_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_calls_generic.subm b/crates/interpreter/tests/fixtures/generics/generic_calls_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_calls_generic.subm rename to crates/interpreter/tests/fixtures/generics/generic_calls_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts b/crates/interpreter/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts rename to crates/interpreter/tests/fixtures/generics/generic_covariant_void_argument_compares_members.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_interface_annotation.subm b/crates/interpreter/tests/fixtures/generics/generic_interface_annotation.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_interface_annotation.subm rename to crates/interpreter/tests/fixtures/generics/generic_interface_annotation.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts b/crates/interpreter/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts rename to crates/interpreter/tests/fixtures/generics/generic_object_argument_infers_callback_fields_last.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_object_round_trip.subm b/crates/interpreter/tests/fixtures/generics/generic_object_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_object_round_trip.subm rename to crates/interpreter/tests/fixtures/generics/generic_object_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_recursion.subm b/crates/interpreter/tests/fixtures/generics/generic_recursion.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_recursion.subm rename to crates/interpreter/tests/fixtures/generics/generic_recursion.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts b/crates/interpreter/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts rename to crates/interpreter/tests/fixtures/generics/generic_result_literal_freshness_per_type_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts b/crates/interpreter/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts rename to crates/interpreter/tests/fixtures/generics/generic_tuple_argument_infers_elements_in_order.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts b/crates/interpreter/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts rename to crates/interpreter/tests/fixtures/generics/generic_union_parameter_infers_from_structured_member.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_naked_priority.ts b/crates/interpreter/tests/fixtures/generics/generic_union_parameter_naked_priority.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_union_parameter_naked_priority.ts rename to crates/interpreter/tests/fixtures/generics/generic_union_parameter_naked_priority.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/generic_variance_measured_once.ts b/crates/interpreter/tests/fixtures/generics/generic_variance_measured_once.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/generic_variance_measured_once.ts rename to crates/interpreter/tests/fixtures/generics/generic_variance_measured_once.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/identity.subm b/crates/interpreter/tests/fixtures/generics/identity.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/identity.subm rename to crates/interpreter/tests/fixtures/generics/identity.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts b/crates/interpreter/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts rename to crates/interpreter/tests/fixtures/generics/inference_through_interfaces_fields_and_nested_calls.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/map_set_aliased_value.subm b/crates/interpreter/tests/fixtures/generics/map_set_aliased_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/map_set_aliased_value.subm rename to crates/interpreter/tests/fixtures/generics/map_set_aliased_value.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/nullish_candidates_infer_their_union.ts b/crates/interpreter/tests/fixtures/generics/nullish_candidates_infer_their_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/nullish_candidates_infer_their_union.ts rename to crates/interpreter/tests/fixtures/generics/nullish_candidates_infer_their_union.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/object_literal_for_generic_interface.ts b/crates/interpreter/tests/fixtures/generics/object_literal_for_generic_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/object_literal_for_generic_interface.ts rename to crates/interpreter/tests/fixtures/generics/object_literal_for_generic_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/recursion.subm b/crates/interpreter/tests/fixtures/generics/recursion.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/recursion.subm rename to crates/interpreter/tests/fixtures/generics/recursion.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/returns_generic_closure.subm b/crates/interpreter/tests/fixtures/generics/returns_generic_closure.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/returns_generic_closure.subm rename to crates/interpreter/tests/fixtures/generics/returns_generic_closure.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/tostring_on_t.subm b/crates/interpreter/tests/fixtures/generics/tostring_on_t.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/tostring_on_t.subm rename to crates/interpreter/tests/fixtures/generics/tostring_on_t.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/tuple_return_generic_fn.ts b/crates/interpreter/tests/fixtures/generics/tuple_return_generic_fn.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/tuple_return_generic_fn.ts rename to crates/interpreter/tests/fixtures/generics/tuple_return_generic_fn.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/uninferred_type_param_is_unknown.subm b/crates/interpreter/tests/fixtures/generics/uninferred_type_param_is_unknown.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/uninferred_type_param_is_unknown.subm rename to crates/interpreter/tests/fixtures/generics/uninferred_type_param_is_unknown.subm diff --git a/crates/submilli-engine/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts b/crates/interpreter/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts rename to crates/interpreter/tests/fixtures/generics/union_parameter_takes_what_others_leave.ts diff --git a/crates/submilli-engine/tests/fixtures/generics/unknown_runtime_descriptor.ts b/crates/interpreter/tests/fixtures/generics/unknown_runtime_descriptor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/generics/unknown_runtime_descriptor.ts rename to crates/interpreter/tests/fixtures/generics/unknown_runtime_descriptor.ts diff --git a/crates/submilli-engine/tests/fixtures/global_array_object_literal.subm b/crates/interpreter/tests/fixtures/global_array_object_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/global_array_object_literal.subm rename to crates/interpreter/tests/fixtures/global_array_object_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/higher_order_function.subm b/crates/interpreter/tests/fixtures/higher_order_function.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/higher_order_function.subm rename to crates/interpreter/tests/fixtures/higher_order_function.subm diff --git a/crates/submilli-engine/tests/fixtures/higher_order_no_literal.ts b/crates/interpreter/tests/fixtures/higher_order_no_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/higher_order_no_literal.ts rename to crates/interpreter/tests/fixtures/higher_order_no_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/higher_order_with_capture.subm b/crates/interpreter/tests/fixtures/higher_order_with_capture.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/higher_order_with_capture.subm rename to crates/interpreter/tests/fixtures/higher_order_with_capture.subm diff --git a/crates/submilli-engine/tests/fixtures/host_error_catchable.subm b/crates/interpreter/tests/fixtures/host_error_catchable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/host_error_catchable.subm rename to crates/interpreter/tests/fixtures/host_error_catchable.subm diff --git a/crates/submilli-engine/tests/fixtures/host_held_values_survive_collection.ts b/crates/interpreter/tests/fixtures/host_held_values_survive_collection.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/host_held_values_survive_collection.ts rename to crates/interpreter/tests/fixtures/host_held_values_survive_collection.ts diff --git a/crates/submilli-engine/tests/fixtures/host_owned_vtables.ts b/crates/interpreter/tests/fixtures/host_owned_vtables.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/host_owned_vtables.ts rename to crates/interpreter/tests/fixtures/host_owned_vtables.ts diff --git a/crates/submilli-engine/tests/fixtures/host_string_struct_spike.ts b/crates/interpreter/tests/fixtures/host_string_struct_spike.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/host_string_struct_spike.ts rename to crates/interpreter/tests/fixtures/host_string_struct_spike.ts diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_download_options_extra_field.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_too_many_args.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_get_too_many_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_too_many_args.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_get_too_many_args.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_with_body.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_get_with_body.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_get_with_body.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_get_with_body.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_type.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_headers_wrong_value_type.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_post_body_wrong_type.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_method.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_method.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_method.subm diff --git a/crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_property.subm b/crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_property.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/http/errors/expect_error_response_unknown_property.subm rename to crates/interpreter/tests/fixtures/http/errors/expect_error_response_unknown_property.subm diff --git a/crates/submilli-engine/tests/fixtures/http_dot_segments.ts b/crates/interpreter/tests/fixtures/http_dot_segments.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/http_dot_segments.ts rename to crates/interpreter/tests/fixtures/http_dot_segments.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/alias_named_from.ts b/crates/interpreter/tests/fixtures/imports/alias_named_from.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/alias_named_from.ts rename to crates/interpreter/tests/fixtures/imports/alias_named_from.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts b/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts rename to crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts b/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts rename to crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest b/crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest rename to crates/interpreter/tests/fixtures/imports/ancestor_only_static_closure/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/imports/embedding_aliased.ts b/crates/interpreter/tests/fixtures/imports/embedding_aliased.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/embedding_aliased.ts rename to crates/interpreter/tests/fixtures/imports/embedding_aliased.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/embedding_named.ts b/crates/interpreter/tests/fixtures/imports/embedding_named.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/embedding_named.ts rename to crates/interpreter/tests/fixtures/imports/embedding_named.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/embedding_namespace.ts b/crates/interpreter/tests/fixtures/imports/embedding_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/embedding_namespace.ts rename to crates/interpreter/tests/fixtures/imports/embedding_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/embedding_wildcard_namespace.ts b/crates/interpreter/tests/fixtures/imports/embedding_wildcard_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/embedding_wildcard_namespace.ts rename to crates/interpreter/tests/fixtures/imports/embedding_wildcard_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/combined_default_named.subm b/crates/interpreter/tests/fixtures/imports/errors/combined_default_named.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/combined_default_named.subm rename to crates/interpreter/tests/fixtures/imports/errors/combined_default_named.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/duplicate_local.subm b/crates/interpreter/tests/fixtures/imports/errors/duplicate_local.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/duplicate_local.subm rename to crates/interpreter/tests/fixtures/imports/errors/duplicate_local.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm b/crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm rename to crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_aliased.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm b/crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm rename to crates/interpreter/tests/fixtures/imports/errors/expect_error_prelude_namespace_star_aliased.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/export_default.subm b/crates/interpreter/tests/fixtures/imports/errors/export_default.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/export_default.subm rename to crates/interpreter/tests/fixtures/imports/errors/export_default.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/export_inside_function_body.subm b/crates/interpreter/tests/fixtures/imports/errors/export_inside_function_body.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/export_inside_function_body.subm rename to crates/interpreter/tests/fixtures/imports/errors/export_inside_function_body.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/export_list.subm b/crates/interpreter/tests/fixtures/imports/errors/export_list.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/export_list.subm rename to crates/interpreter/tests/fixtures/imports/errors/export_list.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/import_in_function.subm b/crates/interpreter/tests/fixtures/imports/errors/import_in_function.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/import_in_function.subm rename to crates/interpreter/tests/fixtures/imports/errors/import_in_function.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/namespace_as_value.subm b/crates/interpreter/tests/fixtures/imports/errors/namespace_as_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/namespace_as_value.subm rename to crates/interpreter/tests/fixtures/imports/errors/namespace_as_value.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/namespace_member_as_value.subm b/crates/interpreter/tests/fixtures/imports/errors/namespace_member_as_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/namespace_member_as_value.subm rename to crates/interpreter/tests/fixtures/imports/errors/namespace_member_as_value.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/relative_import_escapes_root.subm b/crates/interpreter/tests/fixtures/imports/errors/relative_import_escapes_root.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/relative_import_escapes_root.subm rename to crates/interpreter/tests/fixtures/imports/errors/relative_import_escapes_root.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/relative_import_single_file.subm b/crates/interpreter/tests/fixtures/imports/errors/relative_import_single_file.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/relative_import_single_file.subm rename to crates/interpreter/tests/fixtures/imports/errors/relative_import_single_file.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/unknown_named.subm b/crates/interpreter/tests/fixtures/imports/errors/unknown_named.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/unknown_named.subm rename to crates/interpreter/tests/fixtures/imports/errors/unknown_named.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/unknown_namespace_member.subm b/crates/interpreter/tests/fixtures/imports/errors/unknown_namespace_member.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/unknown_namespace_member.subm rename to crates/interpreter/tests/fixtures/imports/errors/unknown_namespace_member.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/unknown_package.subm b/crates/interpreter/tests/fixtures/imports/errors/unknown_package.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/unknown_package.subm rename to crates/interpreter/tests/fixtures/imports/errors/unknown_package.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm b/crates/interpreter/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm rename to crates/interpreter/tests/fixtures/imports/errors/uuid_namespace_not_auto_imported.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/errors/uuid_not_auto_imported.subm b/crates/interpreter/tests/fixtures/imports/errors/uuid_not_auto_imported.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/errors/uuid_not_auto_imported.subm rename to crates/interpreter/tests/fixtures/imports/errors/uuid_not_auto_imported.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/export_modifier_ignored.subm b/crates/interpreter/tests/fixtures/imports/export_modifier_ignored.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/export_modifier_ignored.subm rename to crates/interpreter/tests/fixtures/imports/export_modifier_ignored.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/http_namespace_optional_args.subm b/crates/interpreter/tests/fixtures/imports/http_namespace_optional_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/http_namespace_optional_args.subm rename to crates/interpreter/tests/fixtures/imports/http_namespace_optional_args.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_forgiven.subm b/crates/interpreter/tests/fixtures/imports/import_prelude_namespace_forgiven.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_forgiven.subm rename to crates/interpreter/tests/fixtures/imports/import_prelude_namespace_forgiven.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm b/crates/interpreter/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm rename to crates/interpreter/tests/fixtures/imports/import_prelude_namespace_star_forgiven.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_aliased.ts b/crates/interpreter/tests/fixtures/imports/llm_aliased.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_aliased.ts rename to crates/interpreter/tests/fixtures/imports/llm_aliased.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_named.ts b/crates/interpreter/tests/fixtures/imports/llm_named.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_named.ts rename to crates/interpreter/tests/fixtures/imports/llm_named.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_namespace.ts b/crates/interpreter/tests/fixtures/imports/llm_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_namespace.ts rename to crates/interpreter/tests/fixtures/imports/llm_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/app/main.ts b/crates/interpreter/tests/fixtures/imports/llm_package_caller/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_package_caller/app/main.ts rename to crates/interpreter/tests/fixtures/imports/llm_package_caller/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/packages.manifest b/crates/interpreter/tests/fixtures/imports/llm_package_caller/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_package_caller/packages.manifest rename to crates/interpreter/tests/fixtures/imports/llm_package_caller/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_package_caller/triage/lib.ts b/crates/interpreter/tests/fixtures/imports/llm_package_caller/triage/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_package_caller/triage/lib.ts rename to crates/interpreter/tests/fixtures/imports/llm_package_caller/triage/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/llm_wildcard_namespace.ts b/crates/interpreter/tests/fixtures/imports/llm_wildcard_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/llm_wildcard_namespace.ts rename to crates/interpreter/tests/fixtures/imports/llm_wildcard_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_basic.subm b/crates/interpreter/tests/fixtures/imports/security_check_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_basic.subm rename to crates/interpreter/tests/fixtures/imports/security_check_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_chain/app/main.ts b/crates/interpreter/tests/fixtures/imports/security_check_chain/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_chain/app/main.ts rename to crates/interpreter/tests/fixtures/imports/security_check_chain/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_chain/inner/lib.ts b/crates/interpreter/tests/fixtures/imports/security_check_chain/inner/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_chain/inner/lib.ts rename to crates/interpreter/tests/fixtures/imports/security_check_chain/inner/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_chain/outer/lib.ts b/crates/interpreter/tests/fixtures/imports/security_check_chain/outer/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_chain/outer/lib.ts rename to crates/interpreter/tests/fixtures/imports/security_check_chain/outer/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_chain/packages.manifest b/crates/interpreter/tests/fixtures/imports/security_check_chain/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_chain/packages.manifest rename to crates/interpreter/tests/fixtures/imports/security_check_chain/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/app/main.ts b/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/app/main.ts rename to crates/interpreter/tests/fixtures/imports/security_check_closure_callback/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts b/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts rename to crates/interpreter/tests/fixtures/imports/security_check_closure_callback/inner/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts b/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts rename to crates/interpreter/tests/fixtures/imports/security_check_closure_callback/outer/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/packages.manifest b/crates/interpreter/tests/fixtures/imports/security_check_closure_callback/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_closure_callback/packages.manifest rename to crates/interpreter/tests/fixtures/imports/security_check_closure_callback/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_denied.ts b/crates/interpreter/tests/fixtures/imports/security_check_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_denied.ts rename to crates/interpreter/tests/fixtures/imports/security_check_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/security_check_namespace.subm b/crates/interpreter/tests/fixtures/imports/security_check_namespace.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/security_check_namespace.subm rename to crates/interpreter/tests/fixtures/imports/security_check_namespace.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/session_aliased.ts b/crates/interpreter/tests/fixtures/imports/session_aliased.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_aliased.ts rename to crates/interpreter/tests/fixtures/imports/session_aliased.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/session_named.ts b/crates/interpreter/tests/fixtures/imports/session_named.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_named.ts rename to crates/interpreter/tests/fixtures/imports/session_named.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/session_namespace.ts b/crates/interpreter/tests/fixtures/imports/session_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_namespace.ts rename to crates/interpreter/tests/fixtures/imports/session_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/session_package_caller/app/main.ts b/crates/interpreter/tests/fixtures/imports/session_package_caller/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_package_caller/app/main.ts rename to crates/interpreter/tests/fixtures/imports/session_package_caller/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/session_package_caller/packages.manifest b/crates/interpreter/tests/fixtures/imports/session_package_caller/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_package_caller/packages.manifest rename to crates/interpreter/tests/fixtures/imports/session_package_caller/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/imports/session_package_caller/store/lib.ts b/crates/interpreter/tests/fixtures/imports/session_package_caller/store/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_package_caller/store/lib.ts rename to crates/interpreter/tests/fixtures/imports/session_package_caller/store/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/session_wildcard_namespace.ts b/crates/interpreter/tests/fixtures/imports/session_wildcard_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/session_wildcard_namespace.ts rename to crates/interpreter/tests/fixtures/imports/session_wildcard_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/imports/uuid_aliased.subm b/crates/interpreter/tests/fixtures/imports/uuid_aliased.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/uuid_aliased.subm rename to crates/interpreter/tests/fixtures/imports/uuid_aliased.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/uuid_named.subm b/crates/interpreter/tests/fixtures/imports/uuid_named.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/uuid_named.subm rename to crates/interpreter/tests/fixtures/imports/uuid_named.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/uuid_namespace.subm b/crates/interpreter/tests/fixtures/imports/uuid_namespace.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/uuid_namespace.subm rename to crates/interpreter/tests/fixtures/imports/uuid_namespace.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/uuid_v7.subm b/crates/interpreter/tests/fixtures/imports/uuid_v7.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/uuid_v7.subm rename to crates/interpreter/tests/fixtures/imports/uuid_v7.subm diff --git a/crates/submilli-engine/tests/fixtures/imports/uuid_wildcard_namespace.subm b/crates/interpreter/tests/fixtures/imports/uuid_wildcard_namespace.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/imports/uuid_wildcard_namespace.subm rename to crates/interpreter/tests/fixtures/imports/uuid_wildcard_namespace.subm diff --git a/crates/submilli-engine/tests/fixtures/inferred_closure_return_widening.ts b/crates/interpreter/tests/fixtures/inferred_closure_return_widening.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/inferred_closure_return_widening.ts rename to crates/interpreter/tests/fixtures/inferred_closure_return_widening.ts diff --git a/crates/submilli-engine/tests/fixtures/inferred_literal_extra_fields.ts b/crates/interpreter/tests/fixtures/inferred_literal_extra_fields.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/inferred_literal_extra_fields.ts rename to crates/interpreter/tests/fixtures/inferred_literal_extra_fields.ts diff --git a/crates/submilli-engine/tests/fixtures/infinity_nan_parameter_defaults.ts b/crates/interpreter/tests/fixtures/infinity_nan_parameter_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/infinity_nan_parameter_defaults.ts rename to crates/interpreter/tests/fixtures/infinity_nan_parameter_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/inherited_method_lift_substitutes.ts b/crates/interpreter/tests/fixtures/inherited_method_lift_substitutes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/inherited_method_lift_substitutes.ts rename to crates/interpreter/tests/fixtures/inherited_method_lift_substitutes.ts diff --git a/crates/submilli-engine/tests/fixtures/initializer_narrowing.ts b/crates/interpreter/tests/fixtures/initializer_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/initializer_narrowing.ts rename to crates/interpreter/tests/fixtures/initializer_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/initializer_union_shapes.ts b/crates/interpreter/tests/fixtures/initializer_union_shapes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/initializer_union_shapes.ts rename to crates/interpreter/tests/fixtures/initializer_union_shapes.ts diff --git a/crates/submilli-engine/tests/fixtures/interface_to_string.ts b/crates/interpreter/tests/fixtures/interface_to_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interface_to_string.ts rename to crates/interpreter/tests/fixtures/interface_to_string.ts diff --git a/crates/submilli-engine/tests/fixtures/interface_value_capture.subm b/crates/interpreter/tests/fixtures/interface_value_capture.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interface_value_capture.subm rename to crates/interpreter/tests/fixtures/interface_value_capture.subm diff --git a/crates/submilli-engine/tests/fixtures/interface_value_into_nullable_object_return.ts b/crates/interpreter/tests/fixtures/interface_value_into_nullable_object_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interface_value_into_nullable_object_return.ts rename to crates/interpreter/tests/fixtures/interface_value_into_nullable_object_return.ts diff --git a/crates/submilli-engine/tests/fixtures/interface_value_into_object_slot.ts b/crates/interpreter/tests/fixtures/interface_value_into_object_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interface_value_into_object_slot.ts rename to crates/interpreter/tests/fixtures/interface_value_into_object_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expansive_recursive_assign.ts b/crates/interpreter/tests/fixtures/interfaces/expansive_recursive_assign.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expansive_recursive_assign.ts rename to crates/interpreter/tests/fixtures/interfaces/expansive_recursive_assign.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_bad_member_separator.ts b/crates/interpreter/tests/fixtures/interfaces/expect_error_bad_member_separator.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_bad_member_separator.ts rename to crates/interpreter/tests/fixtures/interfaces/expect_error_bad_member_separator.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts b/crates/interpreter/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts rename to crates/interpreter/tests/fixtures/interfaces/expect_error_expansive_recursive_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts b/crates/interpreter/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts rename to crates/interpreter/tests/fixtures/interfaces/expect_error_finite_recursive_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm b/crates/interpreter/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm rename to crates/interpreter/tests/fixtures/interfaces/expect_error_method_interface_from_object.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm b/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm rename to crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_member.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm b/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm rename to crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_missing_method.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm b/crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm rename to crates/interpreter/tests/fixtures/interfaces/expect_error_user_interface_wrong_method_type.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/interface_property_no_literal.ts b/crates/interpreter/tests/fixtures/interfaces/interface_property_no_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/interface_property_no_literal.ts rename to crates/interpreter/tests/fixtures/interfaces/interface_property_no_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/single_line_members.ts b/crates/interpreter/tests/fixtures/interfaces/single_line_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/single_line_members.ts rename to crates/interpreter/tests/fixtures/interfaces/single_line_members.ts diff --git a/crates/submilli-engine/tests/fixtures/interfaces/structural_object_interface_assign.subm b/crates/interpreter/tests/fixtures/interfaces/structural_object_interface_assign.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/structural_object_interface_assign.subm rename to crates/interpreter/tests/fixtures/interfaces/structural_object_interface_assign.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/user_interface_decl_typechecks.subm b/crates/interpreter/tests/fixtures/interfaces/user_interface_decl_typechecks.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/user_interface_decl_typechecks.subm rename to crates/interpreter/tests/fixtures/interfaces/user_interface_decl_typechecks.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/user_interface_factory.subm b/crates/interpreter/tests/fixtures/interfaces/user_interface_factory.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/user_interface_factory.subm rename to crates/interpreter/tests/fixtures/interfaces/user_interface_factory.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/user_interface_nested_field.subm b/crates/interpreter/tests/fixtures/interfaces/user_interface_nested_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/user_interface_nested_field.subm rename to crates/interpreter/tests/fixtures/interfaces/user_interface_nested_field.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/user_interface_property_read.subm b/crates/interpreter/tests/fixtures/interfaces/user_interface_property_read.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/user_interface_property_read.subm rename to crates/interpreter/tests/fixtures/interfaces/user_interface_property_read.subm diff --git a/crates/submilli-engine/tests/fixtures/interfaces/user_interface_value_method_call.subm b/crates/interpreter/tests/fixtures/interfaces/user_interface_value_method_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/interfaces/user_interface_value_method_call.subm rename to crates/interpreter/tests/fixtures/interfaces/user_interface_value_method_call.subm diff --git a/crates/submilli-engine/tests/fixtures/is_array.subm b/crates/interpreter/tests/fixtures/is_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/is_array.subm rename to crates/interpreter/tests/fixtures/is_array.subm diff --git a/crates/submilli-engine/tests/fixtures/is_primitive.subm b/crates/interpreter/tests/fixtures/is_primitive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/is_primitive.subm rename to crates/interpreter/tests/fixtures/is_primitive.subm diff --git a/crates/submilli-engine/tests/fixtures/issue_1147_array_capacity.ts b/crates/interpreter/tests/fixtures/issue_1147_array_capacity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_1147_array_capacity.ts rename to crates/interpreter/tests/fixtures/issue_1147_array_capacity.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_1147_push_compatibility.ts b/crates/interpreter/tests/fixtures/issue_1147_push_compatibility.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_1147_push_compatibility.ts rename to crates/interpreter/tests/fixtures/issue_1147_push_compatibility.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_821/functions.ts b/crates/interpreter/tests/fixtures/issue_821/functions.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_821/functions.ts rename to crates/interpreter/tests/fixtures/issue_821/functions.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_821/optional_functions.ts b/crates/interpreter/tests/fixtures/issue_821/optional_functions.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_821/optional_functions.ts rename to crates/interpreter/tests/fixtures/issue_821/optional_functions.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_821/top_level_function.ts b/crates/interpreter/tests/fixtures/issue_821/top_level_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_821/top_level_function.ts rename to crates/interpreter/tests/fixtures/issue_821/top_level_function.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_831/cycles.ts b/crates/interpreter/tests/fixtures/issue_831/cycles.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_831/cycles.ts rename to crates/interpreter/tests/fixtures/issue_831/cycles.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_831/mixed_cycles.ts b/crates/interpreter/tests/fixtures/issue_831/mixed_cycles.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_831/mixed_cycles.ts rename to crates/interpreter/tests/fixtures/issue_831/mixed_cycles.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_836/number_format.ts b/crates/interpreter/tests/fixtures/issue_836/number_format.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_836/number_format.ts rename to crates/interpreter/tests/fixtures/issue_836/number_format.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_844/null_algebra.ts b/crates/interpreter/tests/fixtures/issue_844/null_algebra.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_844/null_algebra.ts rename to crates/interpreter/tests/fixtures/issue_844/null_algebra.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_844/null_keys.ts b/crates/interpreter/tests/fixtures/issue_844/null_keys.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_844/null_keys.ts rename to crates/interpreter/tests/fixtures/issue_844/null_keys.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_872/array_discriminant.ts b/crates/interpreter/tests/fixtures/issue_872/array_discriminant.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_872/array_discriminant.ts rename to crates/interpreter/tests/fixtures/issue_872/array_discriminant.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_872/array_guard_boundaries.ts b/crates/interpreter/tests/fixtures/issue_872/array_guard_boundaries.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_872/array_guard_boundaries.ts rename to crates/interpreter/tests/fixtures/issue_872/array_guard_boundaries.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_899/expect_error_distinct_enums.ts b/crates/interpreter/tests/fixtures/issue_899/expect_error_distinct_enums.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_899/expect_error_distinct_enums.ts rename to crates/interpreter/tests/fixtures/issue_899/expect_error_distinct_enums.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_899/primitive_enum.ts b/crates/interpreter/tests/fixtures/issue_899/primitive_enum.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_899/primitive_enum.ts rename to crates/interpreter/tests/fixtures/issue_899/primitive_enum.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_965/global_call_reassignment.ts b/crates/interpreter/tests/fixtures/issue_965/global_call_reassignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_965/global_call_reassignment.ts rename to crates/interpreter/tests/fixtures/issue_965/global_call_reassignment.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_966/insert_optional.ts b/crates/interpreter/tests/fixtures/issue_966/insert_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_966/insert_optional.ts rename to crates/interpreter/tests/fixtures/issue_966/insert_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_966/inserted_fields_json.ts b/crates/interpreter/tests/fixtures/issue_966/inserted_fields_json.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_966/inserted_fields_json.ts rename to crates/interpreter/tests/fixtures/issue_966/inserted_fields_json.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_966/insertion_during_write.ts b/crates/interpreter/tests/fixtures/issue_966/insertion_during_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_966/insertion_during_write.ts rename to crates/interpreter/tests/fixtures/issue_966/insertion_during_write.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_966/insertion_preserves_guards.ts b/crates/interpreter/tests/fixtures/issue_966/insertion_preserves_guards.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_966/insertion_preserves_guards.ts rename to crates/interpreter/tests/fixtures/issue_966/insertion_preserves_guards.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_968/conditional_loop_writes.ts b/crates/interpreter/tests/fixtures/issue_968/conditional_loop_writes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_968/conditional_loop_writes.ts rename to crates/interpreter/tests/fixtures/issue_968/conditional_loop_writes.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_968/nested_loop_writes.ts b/crates/interpreter/tests/fixtures/issue_968/nested_loop_writes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_968/nested_loop_writes.ts rename to crates/interpreter/tests/fixtures/issue_968/nested_loop_writes.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_970/accessor_enumeration.ts b/crates/interpreter/tests/fixtures/issue_970/accessor_enumeration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_970/accessor_enumeration.ts rename to crates/interpreter/tests/fixtures/issue_970/accessor_enumeration.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/compound_literal_operands.ts b/crates/interpreter/tests/fixtures/issue_regressions/compound_literal_operands.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/compound_literal_operands.ts rename to crates/interpreter/tests/fixtures/issue_regressions/compound_literal_operands.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/conditional_literal_results.ts b/crates/interpreter/tests/fixtures/issue_regressions/conditional_literal_results.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/conditional_literal_results.ts rename to crates/interpreter/tests/fixtures/issue_regressions/conditional_literal_results.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/disjunction_guard.ts b/crates/interpreter/tests/fixtures/issue_regressions/disjunction_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/disjunction_guard.ts rename to crates/interpreter/tests/fixtures/issue_regressions/disjunction_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/enum_literal_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/enum_literal_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/enum_literal_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/enum_literal_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_compound_assign_receiver_reported_once.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_conditional_spread_type.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjoint_literal_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_disjunction_partial.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_explicit_void_return.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_finally_break_missing_return.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_literal_false_branch.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_missing_prelude_members.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_negative_literal_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_finally_break.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_nested_switch_break.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_optional_spread_type.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_contravariance.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_polymorphic_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts b/crates/interpreter/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts rename to crates/interpreter/tests/fixtures/issue_regressions/expect_error_switch_try_falls.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/finally_break_return.ts b/crates/interpreter/tests/fixtures/issue_regressions/finally_break_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/finally_break_return.ts rename to crates/interpreter/tests/fixtures/issue_regressions/finally_break_return.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/finite_alias_depth.ts b/crates/interpreter/tests/fixtures/issue_regressions/finite_alias_depth.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/finite_alias_depth.ts rename to crates/interpreter/tests/fixtures/issue_regressions/finite_alias_depth.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/literal_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/literal_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality_aliases.ts b/crates/interpreter/tests/fixtures/issue_regressions/literal_equality_aliases.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/literal_equality_aliases.ts rename to crates/interpreter/tests/fixtures/issue_regressions/literal_equality_aliases.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/logical_interpolation.ts b/crates/interpreter/tests/fixtures/issue_regressions/logical_interpolation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/logical_interpolation.ts rename to crates/interpreter/tests/fixtures/issue_regressions/logical_interpolation.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts b/crates/interpreter/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts rename to crates/interpreter/tests/fixtures/issue_regressions/nested_polymorphic_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/nullable_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/nullable_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/nullable_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/nullable_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread.ts b/crates/interpreter/tests/fixtures/issue_regressions/object_spread.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/object_spread.ts rename to crates/interpreter/tests/fixtures/issue_regressions/object_spread.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_integration.ts b/crates/interpreter/tests/fixtures/issue_regressions/object_spread_integration.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_integration.ts rename to crates/interpreter/tests/fixtures/issue_regressions/object_spread_integration.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_overrides.ts b/crates/interpreter/tests/fixtures/issue_regressions/object_spread_overrides.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_overrides.ts rename to crates/interpreter/tests/fixtures/issue_regressions/object_spread_overrides.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_presence.ts b/crates/interpreter/tests/fixtures/issue_regressions/object_spread_presence.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/object_spread_presence.ts rename to crates/interpreter/tests/fixtures/issue_regressions/object_spread_presence.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/polymorphic_covariance.ts b/crates/interpreter/tests/fixtures/issue_regressions/polymorphic_covariance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/polymorphic_covariance.ts rename to crates/interpreter/tests/fixtures/issue_regressions/polymorphic_covariance.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/signed_literal_equality.ts b/crates/interpreter/tests/fixtures/issue_regressions/signed_literal_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/signed_literal_equality.ts rename to crates/interpreter/tests/fixtures/issue_regressions/signed_literal_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/switch_try_termination.ts b/crates/interpreter/tests/fixtures/issue_regressions/switch_try_termination.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/switch_try_termination.ts rename to crates/interpreter/tests/fixtures/issue_regressions/switch_try_termination.ts diff --git a/crates/submilli-engine/tests/fixtures/issue_regressions/void_callback.ts b/crates/interpreter/tests/fixtures/issue_regressions/void_callback.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/issue_regressions/void_callback.ts rename to crates/interpreter/tests/fixtures/issue_regressions/void_callback.ts diff --git a/crates/submilli-engine/tests/fixtures/iterators/close_called_on_break.subm b/crates/interpreter/tests/fixtures/iterators/close_called_on_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/close_called_on_break.subm rename to crates/interpreter/tests/fixtures/iterators/close_called_on_break.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/close_called_on_exhaustion.subm b/crates/interpreter/tests/fixtures/iterators/close_called_on_exhaustion.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/close_called_on_exhaustion.subm rename to crates/interpreter/tests/fixtures/iterators/close_called_on_exhaustion.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/close_called_on_throw.subm b/crates/interpreter/tests/fixtures/iterators/close_called_on_throw.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/close_called_on_throw.subm rename to crates/interpreter/tests/fixtures/iterators/close_called_on_throw.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm b/crates/interpreter/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm rename to crates/interpreter/tests/fixtures/iterators/iterable_each_loop_closes_own_cursor.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterable_hand_rolled.subm b/crates/interpreter/tests/fixtures/iterators/iterable_hand_rolled.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterable_hand_rolled.subm rename to crates/interpreter/tests/fixtures/iterators/iterable_hand_rolled.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterator_break.subm b/crates/interpreter/tests/fixtures/iterators/iterator_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterator_break.subm rename to crates/interpreter/tests/fixtures/iterators/iterator_break.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterator_continue.subm b/crates/interpreter/tests/fixtures/iterators/iterator_continue.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterator_continue.subm rename to crates/interpreter/tests/fixtures/iterators/iterator_continue.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterator_hand_rolled.subm b/crates/interpreter/tests/fixtures/iterators/iterator_hand_rolled.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterator_hand_rolled.subm rename to crates/interpreter/tests/fixtures/iterators/iterator_hand_rolled.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/iterator_nullable_t.subm b/crates/interpreter/tests/fixtures/iterators/iterator_nullable_t.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/iterator_nullable_t.subm rename to crates/interpreter/tests/fixtures/iterators/iterator_nullable_t.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/no_close_no_crash.subm b/crates/interpreter/tests/fixtures/iterators/no_close_no_crash.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/no_close_no_crash.subm rename to crates/interpreter/tests/fixtures/iterators/no_close_no_crash.subm diff --git a/crates/submilli-engine/tests/fixtures/iterators/user_interface_iterable.subm b/crates/interpreter/tests/fixtures/iterators/user_interface_iterable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/iterators/user_interface_iterable.subm rename to crates/interpreter/tests/fixtures/iterators/user_interface_iterable.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_bare_json.subm b/crates/interpreter/tests/fixtures/json/expect_error_bare_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_bare_json.subm rename to crates/interpreter/tests/fixtures/json/expect_error_bare_json.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_let_json_parse.subm b/crates/interpreter/tests/fixtures/json/expect_error_let_json_parse.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_let_json_parse.subm rename to crates/interpreter/tests/fixtures/json/expect_error_let_json_parse.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_parse_function_target.subm b/crates/interpreter/tests/fixtures/json/expect_error_parse_function_target.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_parse_function_target.subm rename to crates/interpreter/tests/fixtures/json/expect_error_parse_function_target.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_parse_too_many_type_args.subm b/crates/interpreter/tests/fixtures/json/expect_error_parse_too_many_type_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_parse_too_many_type_args.subm rename to crates/interpreter/tests/fixtures/json/expect_error_parse_too_many_type_args.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_parse_type_args_and_as.subm b/crates/interpreter/tests/fixtures/json/expect_error_parse_type_args_and_as.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_parse_type_args_and_as.subm rename to crates/interpreter/tests/fixtures/json/expect_error_parse_type_args_and_as.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_parse_uint8array_target.subm b/crates/interpreter/tests/fixtures/json/expect_error_parse_uint8array_target.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_parse_uint8array_target.subm rename to crates/interpreter/tests/fixtures/json/expect_error_parse_uint8array_target.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_partial_json.subm b/crates/interpreter/tests/fixtures/json/expect_error_partial_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_partial_json.subm rename to crates/interpreter/tests/fixtures/json/expect_error_partial_json.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_stringify_replacer.ts b/crates/interpreter/tests/fixtures/json/expect_error_stringify_replacer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_stringify_replacer.ts rename to crates/interpreter/tests/fixtures/json/expect_error_stringify_replacer.ts diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_stringify_type_args.subm b/crates/interpreter/tests/fixtures/json/expect_error_stringify_type_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_stringify_type_args.subm rename to crates/interpreter/tests/fixtures/json/expect_error_stringify_type_args.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_signature.subm b/crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_signature.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_signature.subm rename to crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_signature.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_type.subm b/crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_to_json_wrong_type.subm rename to crates/interpreter/tests/fixtures/json/expect_error_to_json_wrong_type.subm diff --git a/crates/submilli-engine/tests/fixtures/json/expect_error_unknown_json_member.subm b/crates/interpreter/tests/fixtures/json/expect_error_unknown_json_member.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/expect_error_unknown_json_member.subm rename to crates/interpreter/tests/fixtures/json/expect_error_unknown_json_member.subm diff --git a/crates/submilli-engine/tests/fixtures/json/interface_optional_omitted.ts b/crates/interpreter/tests/fixtures/json/interface_optional_omitted.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/interface_optional_omitted.ts rename to crates/interpreter/tests/fixtures/json/interface_optional_omitted.ts diff --git a/crates/submilli-engine/tests/fixtures/json/main_array_return.subm b/crates/interpreter/tests/fixtures/json/main_array_return.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/main_array_return.subm rename to crates/interpreter/tests/fixtures/json/main_array_return.subm diff --git a/crates/submilli-engine/tests/fixtures/json/main_object_return.subm b/crates/interpreter/tests/fixtures/json/main_object_return.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/main_object_return.subm rename to crates/interpreter/tests/fixtures/json/main_object_return.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_literal.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_literal.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_numbers.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_numbers.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_numbers.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_numbers.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_objects.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_objects.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_objects.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_objects.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_strings.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_strings.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_strings.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_strings.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_tuples.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_tuples.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_tuples.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_tuples.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_array_of_union.subm b/crates/interpreter/tests/fixtures/json/parse_array_of_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_array_of_union.subm rename to crates/interpreter/tests/fixtures/json/parse_array_of_union.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_as_cast.subm b/crates/interpreter/tests/fixtures/json/parse_as_cast.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_as_cast.subm rename to crates/interpreter/tests/fixtures/json/parse_as_cast.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_bool.subm b/crates/interpreter/tests/fixtures/json/parse_bool.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_bool.subm rename to crates/interpreter/tests/fixtures/json/parse_bool.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_diagnostic_preview_path.subm b/crates/interpreter/tests/fixtures/json/parse_diagnostic_preview_path.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_diagnostic_preview_path.subm rename to crates/interpreter/tests/fixtures/json/parse_diagnostic_preview_path.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_explicit_generic.subm b/crates/interpreter/tests/fixtures/json/parse_explicit_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_explicit_generic.subm rename to crates/interpreter/tests/fixtures/json/parse_explicit_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_field_union.subm b/crates/interpreter/tests/fixtures/json/parse_field_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_field_union.subm rename to crates/interpreter/tests/fixtures/json/parse_field_union.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_inferred_interface.ts b/crates/interpreter/tests/fixtures/json/parse_inferred_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_inferred_interface.ts rename to crates/interpreter/tests/fixtures/json/parse_inferred_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/json/parse_into_generic_interface.subm b/crates/interpreter/tests/fixtures/json/parse_into_generic_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_into_generic_interface.subm rename to crates/interpreter/tests/fixtures/json/parse_into_generic_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_into_interface.subm b/crates/interpreter/tests/fixtures/json/parse_into_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_into_interface.subm rename to crates/interpreter/tests/fixtures/json/parse_into_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_into_interface_nested.subm b/crates/interpreter/tests/fixtures/json/parse_into_interface_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_into_interface_nested.subm rename to crates/interpreter/tests/fixtures/json/parse_into_interface_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_into_recursive_interface.subm b/crates/interpreter/tests/fixtures/json/parse_into_recursive_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_into_recursive_interface.subm rename to crates/interpreter/tests/fixtures/json/parse_into_recursive_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_invalid_throws.subm b/crates/interpreter/tests/fixtures/json/parse_invalid_throws.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_invalid_throws.subm rename to crates/interpreter/tests/fixtures/json/parse_invalid_throws.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_mismatch_throws.subm b/crates/interpreter/tests/fixtures/json/parse_mismatch_throws.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_mismatch_throws.subm rename to crates/interpreter/tests/fixtures/json/parse_mismatch_throws.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_nested.subm b/crates/interpreter/tests/fixtures/json/parse_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_nested.subm rename to crates/interpreter/tests/fixtures/json/parse_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_null.subm b/crates/interpreter/tests/fixtures/json/parse_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_null.subm rename to crates/interpreter/tests/fixtures/json/parse_null.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_number.subm b/crates/interpreter/tests/fixtures/json/parse_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_number.subm rename to crates/interpreter/tests/fixtures/json/parse_number.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_number_literal_target.subm b/crates/interpreter/tests/fixtures/json/parse_number_literal_target.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_number_literal_target.subm rename to crates/interpreter/tests/fixtures/json/parse_number_literal_target.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_equals_hash.subm b/crates/interpreter/tests/fixtures/json/parse_object_equals_hash.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_equals_hash.subm rename to crates/interpreter/tests/fixtures/json/parse_object_equals_hash.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_lenient.subm b/crates/interpreter/tests/fixtures/json/parse_object_lenient.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_lenient.subm rename to crates/interpreter/tests/fixtures/json/parse_object_lenient.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_literal_field.subm b/crates/interpreter/tests/fixtures/json/parse_object_literal_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_literal_field.subm rename to crates/interpreter/tests/fixtures/json/parse_object_literal_field.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_nullable_field.subm b/crates/interpreter/tests/fixtures/json/parse_object_nullable_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_nullable_field.subm rename to crates/interpreter/tests/fixtures/json/parse_object_nullable_field.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_optional_field.subm b/crates/interpreter/tests/fixtures/json/parse_object_optional_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_optional_field.subm rename to crates/interpreter/tests/fixtures/json/parse_object_optional_field.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_round_trip.subm b/crates/interpreter/tests/fixtures/json/parse_object_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_round_trip.subm rename to crates/interpreter/tests/fixtures/json/parse_object_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_object_simple.subm b/crates/interpreter/tests/fixtures/json/parse_object_simple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_object_simple.subm rename to crates/interpreter/tests/fixtures/json/parse_object_simple.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_recursive_discriminated.subm b/crates/interpreter/tests/fixtures/json/parse_recursive_discriminated.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_recursive_discriminated.subm rename to crates/interpreter/tests/fixtures/json/parse_recursive_discriminated.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_recursive_linked_list.subm b/crates/interpreter/tests/fixtures/json/parse_recursive_linked_list.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_recursive_linked_list.subm rename to crates/interpreter/tests/fixtures/json/parse_recursive_linked_list.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_recursive_object.subm b/crates/interpreter/tests/fixtures/json/parse_recursive_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_recursive_object.subm rename to crates/interpreter/tests/fixtures/json/parse_recursive_object.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_recursive_union.subm b/crates/interpreter/tests/fixtures/json/parse_recursive_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_recursive_union.subm rename to crates/interpreter/tests/fixtures/json/parse_recursive_union.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_string.subm b/crates/interpreter/tests/fixtures/json/parse_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_string.subm rename to crates/interpreter/tests/fixtures/json/parse_string.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_string_literal_target.subm b/crates/interpreter/tests/fixtures/json/parse_string_literal_target.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_string_literal_target.subm rename to crates/interpreter/tests/fixtures/json/parse_string_literal_target.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_t_or_null.subm b/crates/interpreter/tests/fixtures/json/parse_t_or_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_t_or_null.subm rename to crates/interpreter/tests/fixtures/json/parse_t_or_null.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_tuple_basic.subm b/crates/interpreter/tests/fixtures/json/parse_tuple_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_tuple_basic.subm rename to crates/interpreter/tests/fixtures/json/parse_tuple_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_tuple_in_object.subm b/crates/interpreter/tests/fixtures/json/parse_tuple_in_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_tuple_in_object.subm rename to crates/interpreter/tests/fixtures/json/parse_tuple_in_object.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_tuple_literal_position.subm b/crates/interpreter/tests/fixtures/json/parse_tuple_literal_position.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_tuple_literal_position.subm rename to crates/interpreter/tests/fixtures/json/parse_tuple_literal_position.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_tuple_nested.subm b/crates/interpreter/tests/fixtures/json/parse_tuple_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_tuple_nested.subm rename to crates/interpreter/tests/fixtures/json/parse_tuple_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_tuple_round_trip.subm b/crates/interpreter/tests/fixtures/json/parse_tuple_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_tuple_round_trip.subm rename to crates/interpreter/tests/fixtures/json/parse_tuple_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_literal_set.subm b/crates/interpreter/tests/fixtures/json/parse_union_literal_set.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_literal_set.subm rename to crates/interpreter/tests/fixtures/json/parse_union_literal_set.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_mixed_tags.subm b/crates/interpreter/tests/fixtures/json/parse_union_mixed_tags.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_mixed_tags.subm rename to crates/interpreter/tests/fixtures/json/parse_union_mixed_tags.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_primitive.subm b/crates/interpreter/tests/fixtures/json/parse_union_primitive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_primitive.subm rename to crates/interpreter/tests/fixtures/json/parse_union_primitive.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_shared_tag.subm b/crates/interpreter/tests/fixtures/json/parse_union_shared_tag.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_shared_tag.subm rename to crates/interpreter/tests/fixtures/json/parse_union_shared_tag.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_status_code.subm b/crates/interpreter/tests/fixtures/json/parse_union_status_code.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_status_code.subm rename to crates/interpreter/tests/fixtures/json/parse_union_status_code.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_tagged.subm b/crates/interpreter/tests/fixtures/json/parse_union_tagged.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_tagged.subm rename to crates/interpreter/tests/fixtures/json/parse_union_tagged.subm diff --git a/crates/submilli-engine/tests/fixtures/json/parse_union_untagged.subm b/crates/interpreter/tests/fixtures/json/parse_union_untagged.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/parse_union_untagged.subm rename to crates/interpreter/tests/fixtures/json/parse_union_untagged.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_array.subm b/crates/interpreter/tests/fixtures/json/stringify_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_array.subm rename to crates/interpreter/tests/fixtures/json/stringify_array.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_as_string.subm b/crates/interpreter/tests/fixtures/json/stringify_as_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_as_string.subm rename to crates/interpreter/tests/fixtures/json/stringify_as_string.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_bool.subm b/crates/interpreter/tests/fixtures/json/stringify_bool.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_bool.subm rename to crates/interpreter/tests/fixtures/json/stringify_bool.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_interface_array_round_trip.subm b/crates/interpreter/tests/fixtures/json/stringify_interface_array_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_interface_array_round_trip.subm rename to crates/interpreter/tests/fixtures/json/stringify_interface_array_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_interface_optional_field_assigned.ts b/crates/interpreter/tests/fixtures/json/stringify_interface_optional_field_assigned.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_interface_optional_field_assigned.ts rename to crates/interpreter/tests/fixtures/json/stringify_interface_optional_field_assigned.ts diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_negative_zero.subm b/crates/interpreter/tests/fixtures/json/stringify_negative_zero.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_negative_zero.subm rename to crates/interpreter/tests/fixtures/json/stringify_negative_zero.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_null.subm b/crates/interpreter/tests/fixtures/json/stringify_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_null.subm rename to crates/interpreter/tests/fixtures/json/stringify_null.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_null_valued_nullable_field.subm b/crates/interpreter/tests/fixtures/json/stringify_null_valued_nullable_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_null_valued_nullable_field.subm rename to crates/interpreter/tests/fixtures/json/stringify_null_valued_nullable_field.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_nullable_number.subm b/crates/interpreter/tests/fixtures/json/stringify_nullable_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_nullable_number.subm rename to crates/interpreter/tests/fixtures/json/stringify_nullable_number.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_nullable_object.subm b/crates/interpreter/tests/fixtures/json/stringify_nullable_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_nullable_object.subm rename to crates/interpreter/tests/fixtures/json/stringify_nullable_object.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_nullable_string.subm b/crates/interpreter/tests/fixtures/json/stringify_nullable_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_nullable_string.subm rename to crates/interpreter/tests/fixtures/json/stringify_nullable_string.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_number.subm b/crates/interpreter/tests/fixtures/json/stringify_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_number.subm rename to crates/interpreter/tests/fixtures/json/stringify_number.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_object.subm b/crates/interpreter/tests/fixtures/json/stringify_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_object.subm rename to crates/interpreter/tests/fixtures/json/stringify_object.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_object_optional_field.subm b/crates/interpreter/tests/fixtures/json/stringify_object_optional_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_object_optional_field.subm rename to crates/interpreter/tests/fixtures/json/stringify_object_optional_field.subm diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_pretty_eval_order.ts b/crates/interpreter/tests/fixtures/json/stringify_pretty_eval_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_pretty_eval_order.ts rename to crates/interpreter/tests/fixtures/json/stringify_pretty_eval_order.ts diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_number.ts b/crates/interpreter/tests/fixtures/json/stringify_pretty_space_number.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_number.ts rename to crates/interpreter/tests/fixtures/json/stringify_pretty_space_number.ts diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_string.ts b/crates/interpreter/tests/fixtures/json/stringify_pretty_space_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_pretty_space_string.ts rename to crates/interpreter/tests/fixtures/json/stringify_pretty_space_string.ts diff --git a/crates/submilli-engine/tests/fixtures/json/stringify_string.subm b/crates/interpreter/tests/fixtures/json/stringify_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/stringify_string.subm rename to crates/interpreter/tests/fixtures/json/stringify_string.subm diff --git a/crates/submilli-engine/tests/fixtures/json/to_json_direct.subm b/crates/interpreter/tests/fixtures/json/to_json_direct.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/to_json_direct.subm rename to crates/interpreter/tests/fixtures/json/to_json_direct.subm diff --git a/crates/submilli-engine/tests/fixtures/json/to_json_field_override.subm b/crates/interpreter/tests/fixtures/json/to_json_field_override.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/to_json_field_override.subm rename to crates/interpreter/tests/fixtures/json/to_json_field_override.subm diff --git a/crates/submilli-engine/tests/fixtures/json/to_json_field_override_with_capture.subm b/crates/interpreter/tests/fixtures/json/to_json_field_override_with_capture.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/to_json_field_override_with_capture.subm rename to crates/interpreter/tests/fixtures/json/to_json_field_override_with_capture.subm diff --git a/crates/submilli-engine/tests/fixtures/json/to_json_via_generic.subm b/crates/interpreter/tests/fixtures/json/to_json_via_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/json/to_json_via_generic.subm rename to crates/interpreter/tests/fixtures/json/to_json_via_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/json_parse_lone_surrogate.ts b/crates/interpreter/tests/fixtures/json_parse_lone_surrogate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_parse_lone_surrogate.ts rename to crates/interpreter/tests/fixtures/json_parse_lone_surrogate.ts diff --git a/crates/submilli-engine/tests/fixtures/json_stringify_collection.ts b/crates/interpreter/tests/fixtures/json_stringify_collection.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_stringify_collection.ts rename to crates/interpreter/tests/fixtures/json_stringify_collection.ts diff --git a/crates/submilli-engine/tests/fixtures/json_stringify_erased_null.ts b/crates/interpreter/tests/fixtures/json_stringify_erased_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_stringify_erased_null.ts rename to crates/interpreter/tests/fixtures/json_stringify_erased_null.ts diff --git a/crates/submilli-engine/tests/fixtures/json_stringify_reassigned_field.ts b/crates/interpreter/tests/fixtures/json_stringify_reassigned_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_stringify_reassigned_field.ts rename to crates/interpreter/tests/fixtures/json_stringify_reassigned_field.ts diff --git a/crates/submilli-engine/tests/fixtures/json_stringify_width_subtype.ts b/crates/interpreter/tests/fixtures/json_stringify_width_subtype.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_stringify_width_subtype.ts rename to crates/interpreter/tests/fixtures/json_stringify_width_subtype.ts diff --git a/crates/submilli-engine/tests/fixtures/json_utf16_lossless.ts b/crates/interpreter/tests/fixtures/json_utf16_lossless.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/json_utf16_lossless.ts rename to crates/interpreter/tests/fixtures/json_utf16_lossless.ts diff --git a/crates/submilli-engine/tests/fixtures/later_module_variable_shadows_namespace.ts b/crates/interpreter/tests/fixtures/later_module_variable_shadows_namespace.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/later_module_variable_shadows_namespace.ts rename to crates/interpreter/tests/fixtures/later_module_variable_shadows_namespace.ts diff --git a/crates/submilli-engine/tests/fixtures/let_keeps_regular_literal_types.ts b/crates/interpreter/tests/fixtures/let_keeps_regular_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/let_keeps_regular_literal_types.ts rename to crates/interpreter/tests/fixtures/let_keeps_regular_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/linear_regex_output.ts b/crates/interpreter/tests/fixtures/linear_regex_output.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/linear_regex_output.ts rename to crates/interpreter/tests/fixtures/linear_regex_output.ts diff --git a/crates/submilli-engine/tests/fixtures/linear_string_transforms.ts b/crates/interpreter/tests/fixtures/linear_string_transforms.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/linear_string_transforms.ts rename to crates/interpreter/tests/fixtures/linear_string_transforms.ts diff --git a/crates/submilli-engine/tests/fixtures/literal_keeping_operators.ts b/crates/interpreter/tests/fixtures/literal_keeping_operators.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_keeping_operators.ts rename to crates/interpreter/tests/fixtures/literal_keeping_operators.ts diff --git a/crates/submilli-engine/tests/fixtures/literal_own_type_keeps_binding_writable.ts b/crates/interpreter/tests/fixtures/literal_own_type_keeps_binding_writable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_own_type_keeps_binding_writable.ts rename to crates/interpreter/tests/fixtures/literal_own_type_keeps_binding_writable.ts diff --git a/crates/submilli-engine/tests/fixtures/literal_own_type_under_annotation.ts b/crates/interpreter/tests/fixtures/literal_own_type_under_annotation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_own_type_under_annotation.ts rename to crates/interpreter/tests/fixtures/literal_own_type_under_annotation.ts diff --git a/crates/submilli-engine/tests/fixtures/literal_type_capture.subm b/crates/interpreter/tests/fixtures/literal_type_capture.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_type_capture.subm rename to crates/interpreter/tests/fixtures/literal_type_capture.subm diff --git a/crates/submilli-engine/tests/fixtures/literal_type_number.subm b/crates/interpreter/tests/fixtures/literal_type_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_type_number.subm rename to crates/interpreter/tests/fixtures/literal_type_number.subm diff --git a/crates/submilli-engine/tests/fixtures/literal_type_string.subm b/crates/interpreter/tests/fixtures/literal_type_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_type_string.subm rename to crates/interpreter/tests/fixtures/literal_type_string.subm diff --git a/crates/submilli-engine/tests/fixtures/literal_type_union.subm b/crates/interpreter/tests/fixtures/literal_type_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_type_union.subm rename to crates/interpreter/tests/fixtures/literal_type_union.subm diff --git a/crates/submilli-engine/tests/fixtures/literal_union_interface_field.ts b/crates/interpreter/tests/fixtures/literal_union_interface_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/literal_union_interface_field.ts rename to crates/interpreter/tests/fixtures/literal_union_interface_field.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_basic.ts b/crates/interpreter/tests/fixtures/llm_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_basic.ts rename to crates/interpreter/tests/fixtures/llm_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_batch_ordering.ts b/crates/interpreter/tests/fixtures/llm_batch_ordering.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_batch_ordering.ts rename to crates/interpreter/tests/fixtures/llm_batch_ordering.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_batch_partial_failure.ts b/crates/interpreter/tests/fixtures/llm_batch_partial_failure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_batch_partial_failure.ts rename to crates/interpreter/tests/fixtures/llm_batch_partial_failure.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_budget_aggregate.ts b/crates/interpreter/tests/fixtures/llm_budget_aggregate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_budget_aggregate.ts rename to crates/interpreter/tests/fixtures/llm_budget_aggregate.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_budget_per_execution.ts b/crates/interpreter/tests/fixtures/llm_budget_per_execution.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_budget_per_execution.ts rename to crates/interpreter/tests/fixtures/llm_budget_per_execution.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_budget_release_after_trap.ts b/crates/interpreter/tests/fixtures/llm_budget_release_after_trap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_budget_release_after_trap.ts rename to crates/interpreter/tests/fixtures/llm_budget_release_after_trap.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_call_erased.ts b/crates/interpreter/tests/fixtures/llm_call_erased.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_call_erased.ts rename to crates/interpreter/tests/fixtures/llm_call_erased.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_call_unknown.ts b/crates/interpreter/tests/fixtures/llm_call_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_call_unknown.ts rename to crates/interpreter/tests/fixtures/llm_call_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_denied.ts b/crates/interpreter/tests/fixtures/llm_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_denied.ts rename to crates/interpreter/tests/fixtures/llm_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_error_taxonomy.ts b/crates/interpreter/tests/fixtures/llm_error_taxonomy.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_error_taxonomy.ts rename to crates/interpreter/tests/fixtures/llm_error_taxonomy.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_models_all_callable.ts b/crates/interpreter/tests/fixtures/llm_models_all_callable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_models_all_callable.ts rename to crates/interpreter/tests/fixtures/llm_models_all_callable.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_models_empty.ts b/crates/interpreter/tests/fixtures/llm_models_empty.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_models_empty.ts rename to crates/interpreter/tests/fixtures/llm_models_empty.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_models_filtered.ts b/crates/interpreter/tests/fixtures/llm_models_filtered.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_models_filtered.ts rename to crates/interpreter/tests/fixtures/llm_models_filtered.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_models_no_description.ts b/crates/interpreter/tests/fixtures/llm_models_no_description.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_models_no_description.ts rename to crates/interpreter/tests/fixtures/llm_models_no_description.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_no_provider.ts b/crates/interpreter/tests/fixtures/llm_no_provider.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_no_provider.ts rename to crates/interpreter/tests/fixtures/llm_no_provider.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_prompt_bounds.ts b/crates/interpreter/tests/fixtures/llm_prompt_bounds.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_prompt_bounds.ts rename to crates/interpreter/tests/fixtures/llm_prompt_bounds.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_schema_argument_rejected.ts b/crates/interpreter/tests/fixtures/llm_schema_argument_rejected.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_schema_argument_rejected.ts rename to crates/interpreter/tests/fixtures/llm_schema_argument_rejected.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_schema_unsupported.ts b/crates/interpreter/tests/fixtures/llm_schema_unsupported.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_schema_unsupported.ts rename to crates/interpreter/tests/fixtures/llm_schema_unsupported.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_typed_get.ts b/crates/interpreter/tests/fixtures/llm_typed_get.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_typed_get.ts rename to crates/interpreter/tests/fixtures/llm_typed_get.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_typed_mismatch.ts b/crates/interpreter/tests/fixtures/llm_typed_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_typed_mismatch.ts rename to crates/interpreter/tests/fixtures/llm_typed_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/llm_typed_provider_ignored_schema.ts b/crates/interpreter/tests/fixtures/llm_typed_provider_ignored_schema.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/llm_typed_provider_ignored_schema.ts rename to crates/interpreter/tests/fixtures/llm_typed_provider_ignored_schema.ts diff --git a/crates/submilli-engine/tests/fixtures/loop_condition_write_narrows.ts b/crates/interpreter/tests/fixtures/loop_condition_write_narrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loop_condition_write_narrows.ts rename to crates/interpreter/tests/fixtures/loop_condition_write_narrows.ts diff --git a/crates/submilli-engine/tests/fixtures/loop_empty_body.ts b/crates/interpreter/tests/fixtures/loop_empty_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loop_empty_body.ts rename to crates/interpreter/tests/fixtures/loop_empty_body.ts diff --git a/crates/submilli-engine/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts b/crates/interpreter/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts rename to crates/interpreter/tests/fixtures/loops/body_scope_vs_synthesized_stmts.ts diff --git a/crates/submilli-engine/tests/fixtures/loops/do_while_break.subm b/crates/interpreter/tests/fixtures/loops/do_while_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/do_while_break.subm rename to crates/interpreter/tests/fixtures/loops/do_while_break.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/do_while_continue.ts b/crates/interpreter/tests/fixtures/loops/do_while_continue.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/do_while_continue.ts rename to crates/interpreter/tests/fixtures/loops/do_while_continue.ts diff --git a/crates/submilli-engine/tests/fixtures/loops/do_while_once.subm b/crates/interpreter/tests/fixtures/loops/do_while_once.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/do_while_once.subm rename to crates/interpreter/tests/fixtures/loops/do_while_once.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/do_while_truthiness_cond.subm b/crates/interpreter/tests/fixtures/loops/do_while_truthiness_cond.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/do_while_truthiness_cond.subm rename to crates/interpreter/tests/fixtures/loops/do_while_truthiness_cond.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm b/crates/interpreter/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm rename to crates/interpreter/tests/fixtures/loops/errors/expect_error_break_outside_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm b/crates/interpreter/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm rename to crates/interpreter/tests/fixtures/loops/errors/expect_error_continue_outside_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm b/crates/interpreter/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm rename to crates/interpreter/tests/fixtures/loops/errors/expect_error_for_of_non_array.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_basic.subm b/crates/interpreter/tests/fixtures/loops/for_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_basic.subm rename to crates/interpreter/tests/fixtures/loops/for_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_break.subm b/crates/interpreter/tests/fixtures/loops/for_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_break.subm rename to crates/interpreter/tests/fixtures/loops/for_break.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_continue.subm b/crates/interpreter/tests/fixtures/loops/for_continue.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_continue.subm rename to crates/interpreter/tests/fixtures/loops/for_continue.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_empty_slots.subm b/crates/interpreter/tests/fixtures/loops/for_empty_slots.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_empty_slots.subm rename to crates/interpreter/tests/fixtures/loops/for_empty_slots.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_let_per_iteration_binding.ts b/crates/interpreter/tests/fixtures/loops/for_let_per_iteration_binding.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_let_per_iteration_binding.ts rename to crates/interpreter/tests/fixtures/loops/for_let_per_iteration_binding.ts diff --git a/crates/submilli-engine/tests/fixtures/loops/for_nested.subm b/crates/interpreter/tests/fixtures/loops/for_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_nested.subm rename to crates/interpreter/tests/fixtures/loops/for_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_break.subm b/crates/interpreter/tests/fixtures/loops/for_of_break.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_break.subm rename to crates/interpreter/tests/fixtures/loops/for_of_break.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_continue.subm b/crates/interpreter/tests/fixtures/loops/for_of_continue.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_continue.subm rename to crates/interpreter/tests/fixtures/loops/for_of_continue.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_empty.subm b/crates/interpreter/tests/fixtures/loops/for_of_empty.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_empty.subm rename to crates/interpreter/tests/fixtures/loops/for_of_empty.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_number_array.subm b/crates/interpreter/tests/fixtures/loops/for_of_number_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_number_array.subm rename to crates/interpreter/tests/fixtures/loops/for_of_number_array.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_string_array.subm b/crates/interpreter/tests/fixtures/loops/for_of_string_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_string_array.subm rename to crates/interpreter/tests/fixtures/loops/for_of_string_array.subm diff --git a/crates/submilli-engine/tests/fixtures/loops/for_of_tuple.ts b/crates/interpreter/tests/fixtures/loops/for_of_tuple.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_of_tuple.ts rename to crates/interpreter/tests/fixtures/loops/for_of_tuple.ts diff --git a/crates/submilli-engine/tests/fixtures/loops/for_truthiness_cond.subm b/crates/interpreter/tests/fixtures/loops/for_truthiness_cond.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/loops/for_truthiness_cond.subm rename to crates/interpreter/tests/fixtures/loops/for_truthiness_cond.subm diff --git a/crates/submilli-engine/tests/fixtures/map_for_each.subm b/crates/interpreter/tests/fixtures/map_for_each.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/map_for_each.subm rename to crates/interpreter/tests/fixtures/map_for_each.subm diff --git a/crates/submilli-engine/tests/fixtures/map_from_differing_tuple_literals.ts b/crates/interpreter/tests/fixtures/map_from_differing_tuple_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/map_from_differing_tuple_literals.ts rename to crates/interpreter/tests/fixtures/map_from_differing_tuple_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/map_set_from_iterable.ts b/crates/interpreter/tests/fixtures/map_set_from_iterable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/map_set_from_iterable.ts rename to crates/interpreter/tests/fixtures/map_set_from_iterable.ts diff --git a/crates/submilli-engine/tests/fixtures/map_set_identity.ts b/crates/interpreter/tests/fixtures/map_set_identity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/map_set_identity.ts rename to crates/interpreter/tests/fixtures/map_set_identity.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/basic_string_keys.subm b/crates/interpreter/tests/fixtures/maps/basic_string_keys.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/basic_string_keys.subm rename to crates/interpreter/tests/fixtures/maps/basic_string_keys.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/cached_hashes_and_ledger.ts b/crates/interpreter/tests/fixtures/maps/cached_hashes_and_ledger.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/cached_hashes_and_ledger.ts rename to crates/interpreter/tests/fixtures/maps/cached_hashes_and_ledger.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/ctor_from_entries.subm b/crates/interpreter/tests/fixtures/maps/ctor_from_entries.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/ctor_from_entries.subm rename to crates/interpreter/tests/fixtures/maps/ctor_from_entries.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_for_of_non_iterable.subm b/crates/interpreter/tests/fixtures/maps/expect_error_for_of_non_iterable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_for_of_non_iterable.subm rename to crates/interpreter/tests/fixtures/maps/expect_error_for_of_non_iterable.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_record_type.ts b/crates/interpreter/tests/fixtures/maps/expect_error_record_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_record_type.ts rename to crates/interpreter/tests/fixtures/maps/expect_error_record_type.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_type.subm b/crates/interpreter/tests/fixtures/maps/expect_error_weakmap_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_type.subm rename to crates/interpreter/tests/fixtures/maps/expect_error_weakmap_type.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_value.subm b/crates/interpreter/tests/fixtures/maps/expect_error_weakmap_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_weakmap_value.subm rename to crates/interpreter/tests/fixtures/maps/expect_error_weakmap_value.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_type.subm b/crates/interpreter/tests/fixtures/maps/expect_error_weakset_type.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_type.subm rename to crates/interpreter/tests/fixtures/maps/expect_error_weakset_type.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_value.subm b/crates/interpreter/tests/fixtures/maps/expect_error_weakset_value.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/expect_error_weakset_value.subm rename to crates/interpreter/tests/fixtures/maps/expect_error_weakset_value.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/host_port_roundtrip.ts b/crates/interpreter/tests/fixtures/maps/host_port_roundtrip.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/host_port_roundtrip.ts rename to crates/interpreter/tests/fixtures/maps/host_port_roundtrip.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order.subm b/crates/interpreter/tests/fixtures/maps/insertion_order.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order_after_resize.subm b/crates/interpreter/tests/fixtures/maps/insertion_order_after_resize.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order_after_resize.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order_after_resize.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order_delete_middle.subm b/crates/interpreter/tests/fixtures/maps/insertion_order_delete_middle.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order_delete_middle.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order_delete_middle.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order_set.subm b/crates/interpreter/tests/fixtures/maps/insertion_order_set.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order_set.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order_set.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order_set_after_resize.subm b/crates/interpreter/tests/fixtures/maps/insertion_order_set_after_resize.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order_set_after_resize.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order_set_after_resize.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/insertion_order_set_delete_middle.subm b/crates/interpreter/tests/fixtures/maps/insertion_order_set_delete_middle.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/insertion_order_set_delete_middle.subm rename to crates/interpreter/tests/fixtures/maps/insertion_order_set_delete_middle.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/iterate_for_of.subm b/crates/interpreter/tests/fixtures/maps/iterate_for_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/iterate_for_of.subm rename to crates/interpreter/tests/fixtures/maps/iterate_for_of.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/iterate_iterator_method.subm b/crates/interpreter/tests/fixtures/maps/iterate_iterator_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/iterate_iterator_method.subm rename to crates/interpreter/tests/fixtures/maps/iterate_iterator_method.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/iterate_set_iterator_method.subm b/crates/interpreter/tests/fixtures/maps/iterate_set_iterator_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/iterate_set_iterator_method.subm rename to crates/interpreter/tests/fixtures/maps/iterate_set_iterator_method.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/iterator_concurrent.subm b/crates/interpreter/tests/fixtures/maps/iterator_concurrent.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/iterator_concurrent.subm rename to crates/interpreter/tests/fixtures/maps/iterator_concurrent.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/iterator_sees_later_sets.subm b/crates/interpreter/tests/fixtures/maps/iterator_sees_later_sets.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/iterator_sees_later_sets.subm rename to crates/interpreter/tests/fixtures/maps/iterator_sees_later_sets.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/keys_values_entries_iterators.subm b/crates/interpreter/tests/fixtures/maps/keys_values_entries_iterators.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/keys_values_entries_iterators.subm rename to crates/interpreter/tests/fixtures/maps/keys_values_entries_iterators.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/number_keys.subm b/crates/interpreter/tests/fixtures/maps/number_keys.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/number_keys.subm rename to crates/interpreter/tests/fixtures/maps/number_keys.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/object_keys.subm b/crates/interpreter/tests/fixtures/maps/object_keys.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/object_keys.subm rename to crates/interpreter/tests/fixtures/maps/object_keys.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/object_values_get_field_access.subm b/crates/interpreter/tests/fixtures/maps/object_values_get_field_access.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/object_values_get_field_access.subm rename to crates/interpreter/tests/fixtures/maps/object_values_get_field_access.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/phase2_typecheck.subm b/crates/interpreter/tests/fixtures/maps/phase2_typecheck.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/phase2_typecheck.subm rename to crates/interpreter/tests/fixtures/maps/phase2_typecheck.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/phase6_for_of_typecheck.subm b/crates/interpreter/tests/fixtures/maps/phase6_for_of_typecheck.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/phase6_for_of_typecheck.subm rename to crates/interpreter/tests/fixtures/maps/phase6_for_of_typecheck.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/postfix_chain_on_new.subm b/crates/interpreter/tests/fixtures/maps/postfix_chain_on_new.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/postfix_chain_on_new.subm rename to crates/interpreter/tests/fixtures/maps/postfix_chain_on_new.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/resize.subm b/crates/interpreter/tests/fixtures/maps/resize.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/resize.subm rename to crates/interpreter/tests/fixtures/maps/resize.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/set_basic.subm b/crates/interpreter/tests/fixtures/maps/set_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/set_basic.subm rename to crates/interpreter/tests/fixtures/maps/set_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/set_ctor_from_values.subm b/crates/interpreter/tests/fixtures/maps/set_ctor_from_values.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/set_ctor_from_values.subm rename to crates/interpreter/tests/fixtures/maps/set_ctor_from_values.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/set_host_port_roundtrip.ts b/crates/interpreter/tests/fixtures/maps/set_host_port_roundtrip.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/set_host_port_roundtrip.ts rename to crates/interpreter/tests/fixtures/maps/set_host_port_roundtrip.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/set_iterate.subm b/crates/interpreter/tests/fixtures/maps/set_iterate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/set_iterate.subm rename to crates/interpreter/tests/fixtures/maps/set_iterate.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/set_keys_values_entries_iterators.subm b/crates/interpreter/tests/fixtures/maps/set_keys_values_entries_iterators.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/set_keys_values_entries_iterators.subm rename to crates/interpreter/tests/fixtures/maps/set_keys_values_entries_iterators.subm diff --git a/crates/submilli-engine/tests/fixtures/maps/tombstone_reclamation.ts b/crates/interpreter/tests/fixtures/maps/tombstone_reclamation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/tombstone_reclamation.ts rename to crates/interpreter/tests/fixtures/maps/tombstone_reclamation.ts diff --git a/crates/submilli-engine/tests/fixtures/maps/tombstone_reuse.subm b/crates/interpreter/tests/fixtures/maps/tombstone_reuse.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/maps/tombstone_reuse.subm rename to crates/interpreter/tests/fixtures/maps/tombstone_reuse.subm diff --git a/crates/submilli-engine/tests/fixtures/math_basic.subm b/crates/interpreter/tests/fixtures/math_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_basic.subm rename to crates/interpreter/tests/fixtures/math_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/math_constants.subm b/crates/interpreter/tests/fixtures/math_constants.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_constants.subm rename to crates/interpreter/tests/fixtures/math_constants.subm diff --git a/crates/submilli-engine/tests/fixtures/math_hypot.subm b/crates/interpreter/tests/fixtures/math_hypot.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_hypot.subm rename to crates/interpreter/tests/fixtures/math_hypot.subm diff --git a/crates/submilli-engine/tests/fixtures/math_pi.subm b/crates/interpreter/tests/fixtures/math_pi.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_pi.subm rename to crates/interpreter/tests/fixtures/math_pi.subm diff --git a/crates/submilli-engine/tests/fixtures/math_random.subm b/crates/interpreter/tests/fixtures/math_random.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_random.subm rename to crates/interpreter/tests/fixtures/math_random.subm diff --git a/crates/submilli-engine/tests/fixtures/math_transcendentals.subm b/crates/interpreter/tests/fixtures/math_transcendentals.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/math_transcendentals.subm rename to crates/interpreter/tests/fixtures/math_transcendentals.subm diff --git a/crates/submilli-engine/tests/fixtures/method_call_through_string_key.ts b/crates/interpreter/tests/fixtures/method_call_through_string_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/method_call_through_string_key.ts rename to crates/interpreter/tests/fixtures/method_call_through_string_key.ts diff --git a/crates/submilli-engine/tests/fixtures/method_lift_substitutes_receiver_args.ts b/crates/interpreter/tests/fixtures/method_lift_substitutes_receiver_args.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/method_lift_substitutes_receiver_args.ts rename to crates/interpreter/tests/fixtures/method_lift_substitutes_receiver_args.ts diff --git a/crates/submilli-engine/tests/fixtures/module_let_narrowing_reads_live_after_call.ts b/crates/interpreter/tests/fixtures/module_let_narrowing_reads_live_after_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/module_let_narrowing_reads_live_after_call.ts rename to crates/interpreter/tests/fixtures/module_let_narrowing_reads_live_after_call.ts diff --git a/crates/submilli-engine/tests/fixtures/module_variable_before_initialization.ts b/crates/interpreter/tests/fixtures/module_variable_before_initialization.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/module_variable_before_initialization.ts rename to crates/interpreter/tests/fixtures/module_variable_before_initialization.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/lib.ts b/crates/interpreter/tests/fixtures/multi/aliased_enum_import/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/lib.ts rename to crates/interpreter/tests/fixtures/multi/aliased_enum_import/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/m_enum.ts b/crates/interpreter/tests/fixtures/multi/aliased_enum_import/m_enum.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/aliased_enum_import/m_enum.ts rename to crates/interpreter/tests/fixtures/multi/aliased_enum_import/m_enum.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/lib.ts b/crates/interpreter/tests/fixtures/multi/default_param_cross_module/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/lib.ts rename to crates/interpreter/tests/fixtures/multi/default_param_cross_module/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/util.ts b/crates/interpreter/tests/fixtures/multi/default_param_cross_module/util.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/default_param_cross_module/util.ts rename to crates/interpreter/tests/fixtures/multi/default_param_cross_module/util.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts b/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts rename to crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm b/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm rename to crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts b/crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts rename to crates/interpreter/tests/fixtures/multi/errors/ambiguous_ts_subm/wrap.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/cycle/b.subm b/crates/interpreter/tests/fixtures/multi/errors/cycle/b.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/cycle/b.subm rename to crates/interpreter/tests/fixtures/multi/errors/cycle/b.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/cycle/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/cycle/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/cycle/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/cycle/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/main_decl/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/main_decl/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/main_decl/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/main_decl/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/missing_module/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/missing_module/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/missing_module/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/missing_module/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_function_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_global_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/module_exported_type_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_exported_function_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_exported_type_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_reexported_function_type_references_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm b/crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/package_reexported_global_type_references_private_type/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/lib.subm b/crates/interpreter/tests/fixtures/multi/errors/private_symbol/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/lib.subm rename to crates/interpreter/tests/fixtures/multi/errors/private_symbol/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/util.subm b/crates/interpreter/tests/fixtures/multi/errors/private_symbol/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/errors/private_symbol/util.subm rename to crates/interpreter/tests/fixtures/multi/errors/private_symbol/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_documented/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_direct_documented/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_documented/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_direct_documented/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_missing/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_direct_missing/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_direct_missing/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_direct_missing/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_interface_member/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_interface_member/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_interface_member/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_interface_member/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_internal_helper/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_internal_helper/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_internal_helper/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_internal_helper/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/util.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/util.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_reexport_missing/util.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_reexport_missing/util.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/lib.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/lib.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/util.ts b/crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/util.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_docs_sibling_only/util.ts rename to crates/interpreter/tests/fixtures/multi/exported_docs_sibling_only/util.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/lib.subm b/crates/interpreter/tests/fixtures/multi/exported_function_type_surface/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/lib.subm rename to crates/interpreter/tests/fixtures/multi/exported_function_type_surface/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/util.subm b/crates/interpreter/tests/fixtures/multi/exported_function_type_surface/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/exported_function_type_surface/util.subm rename to crates/interpreter/tests/fixtures/multi/exported_function_type_surface/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/namespace_import/lib.subm b/crates/interpreter/tests/fixtures/multi/namespace_import/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/namespace_import/lib.subm rename to crates/interpreter/tests/fixtures/multi/namespace_import/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/namespace_import/util.subm b/crates/interpreter/tests/fixtures/multi/namespace_import/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/namespace_import/util.subm rename to crates/interpreter/tests/fixtures/multi/namespace_import/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm b/crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm rename to crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm b/crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm rename to crates/interpreter/tests/fixtures/multi/package_reexported_recursive_type_surface/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/reexport_basic/lib.subm b/crates/interpreter/tests/fixtures/multi/reexport_basic/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/reexport_basic/lib.subm rename to crates/interpreter/tests/fixtures/multi/reexport_basic/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/reexport_basic/util.subm b/crates/interpreter/tests/fixtures/multi/reexport_basic/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/reexport_basic/util.subm rename to crates/interpreter/tests/fixtures/multi/reexport_basic/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/lib.ts b/crates/interpreter/tests/fixtures/multi/reserved_word_export_names/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/lib.ts rename to crates/interpreter/tests/fixtures/multi/reserved_word_export_names/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/values.ts b/crates/interpreter/tests/fixtures/multi/reserved_word_export_names/values.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/reserved_word_export_names/values.ts rename to crates/interpreter/tests/fixtures/multi/reserved_word_export_names/values.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/sibling_import/lib.subm b/crates/interpreter/tests/fixtures/multi/sibling_import/lib.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/sibling_import/lib.subm rename to crates/interpreter/tests/fixtures/multi/sibling_import/lib.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/sibling_import/util.subm b/crates/interpreter/tests/fixtures/multi/sibling_import/util.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/sibling_import/util.subm rename to crates/interpreter/tests/fixtures/multi/sibling_import/util.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts b/crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts rename to crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts b/crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts rename to crates/interpreter/tests/fixtures/multi/signature_lift_unimported_receiver_type/widget.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/ts_mixed/lib.ts b/crates/interpreter/tests/fixtures/multi/ts_mixed/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/ts_mixed/lib.ts rename to crates/interpreter/tests/fixtures/multi/ts_mixed/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/ts_mixed/wrap.subm b/crates/interpreter/tests/fixtures/multi/ts_mixed/wrap.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/ts_mixed/wrap.subm rename to crates/interpreter/tests/fixtures/multi/ts_mixed/wrap.subm diff --git a/crates/submilli-engine/tests/fixtures/multi/type_only_reexport/lib.ts b/crates/interpreter/tests/fixtures/multi/type_only_reexport/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/type_only_reexport/lib.ts rename to crates/interpreter/tests/fixtures/multi/type_only_reexport/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/type_only_reexport/util.ts b/crates/interpreter/tests/fixtures/multi/type_only_reexport/util.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/type_only_reexport/util.ts rename to crates/interpreter/tests/fixtures/multi/type_only_reexport/util.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/lib.ts b/crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/lib.ts rename to crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/widget.ts b/crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/widget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/multi/union_write_help_unimported_member/widget.ts rename to crates/interpreter/tests/fixtures/multi/union_write_help_unimported_member/widget.ts diff --git a/crates/submilli-engine/tests/fixtures/mvp_greet.subm b/crates/interpreter/tests/fixtures/mvp_greet.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/mvp_greet.subm rename to crates/interpreter/tests/fixtures/mvp_greet.subm diff --git a/crates/submilli-engine/tests/fixtures/namespace_shadowed_by_top_level.ts b/crates/interpreter/tests/fixtures/namespace_shadowed_by_top_level.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/namespace_shadowed_by_top_level.ts rename to crates/interpreter/tests/fixtures/namespace_shadowed_by_top_level.ts diff --git a/crates/submilli-engine/tests/fixtures/nan_local_binding_not_flagged.ts b/crates/interpreter/tests/fixtures/nan_local_binding_not_flagged.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nan_local_binding_not_flagged.ts rename to crates/interpreter/tests/fixtures/nan_local_binding_not_flagged.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowed_boxed_binding_read.ts b/crates/interpreter/tests/fixtures/narrowed_boxed_binding_read.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowed_boxed_binding_read.ts rename to crates/interpreter/tests/fixtures/narrowed_boxed_binding_read.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/aliased_conditions_narrow.ts b/crates/interpreter/tests/fixtures/narrowing/aliased_conditions_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/aliased_conditions_narrow.ts rename to crates/interpreter/tests/fixtures/narrowing/aliased_conditions_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/array_isarray_narrows.subm b/crates/interpreter/tests/fixtures/narrowing/array_isarray_narrows.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/array_isarray_narrows.subm rename to crates/interpreter/tests/fixtures/narrowing/array_isarray_narrows.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/array_isarray_on_generic.subm b/crates/interpreter/tests/fixtures/narrowing/array_isarray_on_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/array_isarray_on_generic.subm rename to crates/interpreter/tests/fixtures/narrowing/array_isarray_on_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts b/crates/interpreter/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts rename to crates/interpreter/tests/fixtures/narrowing/assign_narrow_then_rewiden.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assign_narrowing_survives_join.ts b/crates/interpreter/tests/fixtures/narrowing/assign_narrowing_survives_join.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assign_narrowing_survives_join.ts rename to crates/interpreter/tests/fixtures/narrowing/assign_narrowing_survives_join.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assign_narrows_block_tail.subm b/crates/interpreter/tests/fixtures/narrowing/assign_narrows_block_tail.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assign_narrows_block_tail.subm rename to crates/interpreter/tests/fixtures/narrowing/assign_narrows_block_tail.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assign_sibling_invalidates.subm b/crates/interpreter/tests/fixtures/narrowing/assign_sibling_invalidates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assign_sibling_invalidates.subm rename to crates/interpreter/tests/fixtures/narrowing/assign_sibling_invalidates.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assign_then_call_invalidates.subm b/crates/interpreter/tests/fixtures/narrowing/assign_then_call_invalidates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assign_then_call_invalidates.subm rename to crates/interpreter/tests/fixtures/narrowing/assign_then_call_invalidates.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/assignment_value_truthiness.ts b/crates/interpreter/tests/fixtures/narrowing/assignment_value_truthiness.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/assignment_value_truthiness.ts rename to crates/interpreter/tests/fixtures/narrowing/assignment_value_truthiness.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts b/crates/interpreter/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts rename to crates/interpreter/tests/fixtures/narrowing/back_edge_narrowing_not_at_entry.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm b/crates/interpreter/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm rename to crates/interpreter/tests/fixtures/narrowing/call_preserves_identifier_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm b/crates/interpreter/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm rename to crates/interpreter/tests/fixtures/narrowing/call_preserves_property_path_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/call_rereads_field_path.ts b/crates/interpreter/tests/fixtures/narrowing/call_rereads_field_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/call_rereads_field_path.ts rename to crates/interpreter/tests/fixtures/narrowing/call_rereads_field_path.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/captured_mutator_write_back.ts b/crates/interpreter/tests/fixtures/narrowing/captured_mutator_write_back.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/captured_mutator_write_back.ts rename to crates/interpreter/tests/fixtures/narrowing/captured_mutator_write_back.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/chained_short_circuit.subm b/crates/interpreter/tests/fixtures/narrowing/chained_short_circuit.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/chained_short_circuit.subm rename to crates/interpreter/tests/fixtures/narrowing/chained_short_circuit.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/class_field_and_chain.ts b/crates/interpreter/tests/fixtures/narrowing/class_field_and_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/class_field_and_chain.ts rename to crates/interpreter/tests/fixtures/narrowing/class_field_and_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/class_field_nested_if.ts b/crates/interpreter/tests/fixtures/narrowing/class_field_nested_if.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/class_field_nested_if.ts rename to crates/interpreter/tests/fixtures/narrowing/class_field_nested_if.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/class_private_field_same_module.ts b/crates/interpreter/tests/fixtures/narrowing/class_private_field_same_module.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/class_private_field_same_module.ts rename to crates/interpreter/tests/fixtures/narrowing/class_private_field_same_module.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/closure_last_assignment.ts b/crates/interpreter/tests/fixtures/narrowing/closure_last_assignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/closure_last_assignment.ts rename to crates/interpreter/tests/fixtures/narrowing/closure_last_assignment.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/closure_reguards_field_path.ts b/crates/interpreter/tests/fixtures/narrowing/closure_reguards_field_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/closure_reguards_field_path.ts rename to crates/interpreter/tests/fixtures/narrowing/closure_reguards_field_path.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/computed_write_retains_literal_type.ts b/crates/interpreter/tests/fixtures/narrowing/computed_write_retains_literal_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/computed_write_retains_literal_type.ts rename to crates/interpreter/tests/fixtures/narrowing/computed_write_retains_literal_type.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_for_of_const.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_nested_arrow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_param_shadow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_returns_later.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_top_level.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_top_level.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_top_level.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_top_level.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_closure_typeof_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/const_narrow_survives_closure.ts b/crates/interpreter/tests/fixtures/narrowing/const_narrow_survives_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/const_narrow_survives_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/const_narrow_survives_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_equality.subm b/crates/interpreter/tests/fixtures/narrowing/discriminant_kind_equality.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_equality.subm rename to crates/interpreter/tests/fixtures/narrowing/discriminant_kind_equality.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_inequality.subm b/crates/interpreter/tests/fixtures/narrowing/discriminant_kind_inequality.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/discriminant_kind_inequality.subm rename to crates/interpreter/tests/fixtures/narrowing/discriminant_kind_inequality.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/discriminant_member_sets.ts b/crates/interpreter/tests/fixtures/narrowing/discriminant_member_sets.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/discriminant_member_sets.ts rename to crates/interpreter/tests/fixtures/narrowing/discriminant_member_sets.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/discriminant_three_variants.subm b/crates/interpreter/tests/fixtures/narrowing/discriminant_three_variants.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/discriminant_three_variants.subm rename to crates/interpreter/tests/fixtures/narrowing/discriminant_three_variants.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts b/crates/interpreter/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts rename to crates/interpreter/tests/fixtures/narrowing/do_while_back_edge_wraps_body.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/dropped_index_path_hint.ts b/crates/interpreter/tests/fixtures/narrowing/dropped_index_path_hint.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/dropped_index_path_hint.ts rename to crates/interpreter/tests/fixtures/narrowing/dropped_index_path_hint.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/enum_discriminant_case.ts b/crates/interpreter/tests/fixtures/narrowing/enum_discriminant_case.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/enum_discriminant_case.ts rename to crates/interpreter/tests/fixtures/narrowing/enum_discriminant_case.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts b/crates/interpreter/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts rename to crates/interpreter/tests/fixtures/narrowing/enum_exclusions_reach_switch_and_predicate.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts b/crates/interpreter/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts rename to crates/interpreter/tests/fixtures/narrowing/enum_exclusions_survive_other_checks.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts b/crates/interpreter/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts rename to crates/interpreter/tests/fixtures/narrowing/enum_tuple_and_variable_discriminants.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/equality_between_unions.ts b/crates/interpreter/tests/fixtures/narrowing/equality_between_unions.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/equality_between_unions.ts rename to crates/interpreter/tests/fixtures/narrowing/equality_between_unions.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts b/crates/interpreter/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts rename to crates/interpreter/tests/fixtures/narrowing/exhaustive_switch_after_stale_narrowing_throws.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_aliased_condition_needs_constant_reference.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_assign_narrowing_leaves_try.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_narrow_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_assignment_value_truthiness_rules_out.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_back_edge_narrowing_at_entry.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_captured_mutating_let.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_computed_key_guard_written_by_name.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_destructured_parameter_reassigned.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_do_while_continue_widens.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_enum_exclusions_keep_unchecked_member.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_equal_to_type_parameter_keeps_null.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_equality_keeps_overlapping_objects.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_field_path_narrow_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_field_with_every_member_ruled_out_is_not_never.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_catch_throw.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_continue_write.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_continue_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_continue_write.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_continue_write.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_do.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_do.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_do.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_do.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_for.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_for.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_for.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_for.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_forof.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_forof.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_forof.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_forof.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_while.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_while.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_field_while.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_field_while.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_finally_break.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_finally_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_finally_break.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_finally_break.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_direct.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_direct.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_direct.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_direct.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_nested.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_nested.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_nested.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_nested.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_switch.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_switch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_switch.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_switch.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_try.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_try.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_local_try.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_local_try.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_root_reassignment.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_update.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_update.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_update.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_update.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_do.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_for.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_forof.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_flow_zero_reachable_while.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_for_update_continue_widens.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_function_union_assignment_short_call.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_generic_member_is_not_a_discriminant.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_cast.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_cast.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_cast.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_cast.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_index.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_index.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_index.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_index.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_getter_path_prefix.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_in_operator_primitive_rhs.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_index_by_changing_key.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_let_narrow_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_missing_return_in_narrow_region.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_module_let_written_by_function.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_more_narrowing_hints.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_never_array_element_keeps_its_type.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_nominal_union_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_nullable_rw_target.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_operator_narrowing_hint.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_param_narrow_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_property_path_field_write_invalidates.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_reassign_same_type_kills_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_rejected_write_keeps_declared_type.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_switch_last_clause_runs_off_end.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_switch_no_match_exit_narrows.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts b/crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts rename to crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_code_reads_declared_types.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_unreachable_in_narrow_region.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_body_unsound.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_generic_unsound.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_in_alias.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_not_param.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_user_guard_type_alias_unsound.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm b/crates/interpreter/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm rename to crates/interpreter/tests/fixtures/narrowing/expect_error_write_still_invalidates_after_call.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/field_path_two_deep_structural.ts b/crates/interpreter/tests/fixtures/narrowing/field_path_two_deep_structural.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/field_path_two_deep_structural.ts rename to crates/interpreter/tests/fixtures/narrowing/field_path_two_deep_structural.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_clause_joins.ts b/crates/interpreter/tests/fixtures/narrowing/flow_clause_joins.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_clause_joins.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_clause_joins.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_condition_preserved.ts b/crates/interpreter/tests/fixtures/narrowing/flow_condition_preserved.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_condition_preserved.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_condition_preserved.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_do_break.ts b/crates/interpreter/tests/fixtures/narrowing/flow_do_break.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_do_break.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_do_break.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_for_condition_preserved.ts b/crates/interpreter/tests/fixtures/narrowing/flow_for_condition_preserved.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_for_condition_preserved.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_for_condition_preserved.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_join_820.ts b/crates/interpreter/tests/fixtures/narrowing/flow_join_820.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_join_820.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_join_820.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_join_898.ts b/crates/interpreter/tests/fixtures/narrowing/flow_join_898.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_join_898.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_join_898.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_join_901.ts b/crates/interpreter/tests/fixtures/narrowing/flow_join_901.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_join_901.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_join_901.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_join_902.ts b/crates/interpreter/tests/fixtures/narrowing/flow_join_902.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_join_902.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_join_902.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_loops.ts b/crates/interpreter/tests/fixtures/narrowing/flow_loops.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_loops.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_loops.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_numeric_source.ts b/crates/interpreter/tests/fixtures/narrowing/flow_numeric_source.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_numeric_source.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_numeric_source.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_switch_unmatched.ts b/crates/interpreter/tests/fixtures/narrowing/flow_switch_unmatched.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_switch_unmatched.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_switch_unmatched.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/flow_this_for.ts b/crates/interpreter/tests/fixtures/narrowing/flow_this_for.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/flow_this_for.ts rename to crates/interpreter/tests/fixtures/narrowing/flow_this_for.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts b/crates/interpreter/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts rename to crates/interpreter/tests/fixtures/narrowing/for_cond_narrow_wraps_body.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm b/crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm rename to crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_number.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm b/crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm rename to crates/interpreter/tests/fixtures/narrowing/for_loop_mutated_let_null_guard_string.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts b/crates/interpreter/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts rename to crates/interpreter/tests/fixtures/narrowing/for_of_back_edge_wraps_body.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts b/crates/interpreter/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts rename to crates/interpreter/tests/fixtures/narrowing/for_of_body_local_continue_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts b/crates/interpreter/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts rename to crates/interpreter/tests/fixtures/narrowing/for_of_loop_var_continue_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts b/crates/interpreter/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts rename to crates/interpreter/tests/fixtures/narrowing/for_update_runs_on_back_edge.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/function_union_assignment.ts b/crates/interpreter/tests/fixtures/narrowing/function_union_assignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/function_union_assignment.ts rename to crates/interpreter/tests/fixtures/narrowing/function_union_assignment.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/generic_class_box_of_box.ts b/crates/interpreter/tests/fixtures/narrowing/generic_class_box_of_box.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/generic_class_box_of_box.ts rename to crates/interpreter/tests/fixtures/narrowing/generic_class_box_of_box.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/global_field_paths.ts b/crates/interpreter/tests/fixtures/narrowing/global_field_paths.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/global_field_paths.ts rename to crates/interpreter/tests/fixtures/narrowing/global_field_paths.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/global_guard_mutation.ts b/crates/interpreter/tests/fixtures/narrowing/global_guard_mutation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/global_guard_mutation.ts rename to crates/interpreter/tests/fixtures/narrowing/global_guard_mutation.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/global_ternary_null.ts b/crates/interpreter/tests/fixtures/narrowing/global_ternary_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/global_ternary_null.ts rename to crates/interpreter/tests/fixtures/narrowing/global_ternary_null.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/guard_through_an_element.ts b/crates/interpreter/tests/fixtures/narrowing/guard_through_an_element.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/guard_through_an_element.ts rename to crates/interpreter/tests/fixtures/narrowing/guard_through_an_element.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/immediately_invoked_functions.ts b/crates/interpreter/tests/fixtures/narrowing/immediately_invoked_functions.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/immediately_invoked_functions.ts rename to crates/interpreter/tests/fixtures/narrowing/immediately_invoked_functions.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/in_operator_basic_object.subm b/crates/interpreter/tests/fixtures/narrowing/in_operator_basic_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/in_operator_basic_object.subm rename to crates/interpreter/tests/fixtures/narrowing/in_operator_basic_object.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/in_operator_dynamic_key.ts b/crates/interpreter/tests/fixtures/narrowing/in_operator_dynamic_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/in_operator_dynamic_key.ts rename to crates/interpreter/tests/fixtures/narrowing/in_operator_dynamic_key.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/in_operator_union_filter.subm b/crates/interpreter/tests/fixtures/narrowing/in_operator_union_filter.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/in_operator_union_filter.subm rename to crates/interpreter/tests/fixtures/narrowing/in_operator_union_filter.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/in_operator_unknown_chain.subm b/crates/interpreter/tests/fixtures/narrowing/in_operator_unknown_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/in_operator_unknown_chain.subm rename to crates/interpreter/tests/fixtures/narrowing/in_operator_unknown_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/in_typeof_field_chain.subm b/crates/interpreter/tests/fixtures/narrowing/in_typeof_field_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/in_typeof_field_chain.subm rename to crates/interpreter/tests/fixtures/narrowing/in_typeof_field_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/index_by_constant_key.ts b/crates/interpreter/tests/fixtures/narrowing/index_by_constant_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/index_by_constant_key.ts rename to crates/interpreter/tests/fixtures/narrowing/index_by_constant_key.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/index_path_and_chain.ts b/crates/interpreter/tests/fixtures/narrowing/index_path_and_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/index_path_and_chain.ts rename to crates/interpreter/tests/fixtures/narrowing/index_path_and_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/interface_field_holding_class.ts b/crates/interpreter/tests/fixtures/narrowing/interface_field_holding_class.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/interface_field_holding_class.ts rename to crates/interpreter/tests/fixtures/narrowing/interface_field_holding_class.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_785_chain.ts b/crates/interpreter/tests/fixtures/narrowing/issue_785_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_785_chain.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_785_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts b/crates/interpreter/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_785_expect_error_null_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_785_switch.ts b/crates/interpreter/tests/fixtures/narrowing/issue_785_switch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_785_switch.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_785_switch.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_786.ts b/crates/interpreter/tests/fixtures/narrowing/issue_786.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_786.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_786.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts b/crates/interpreter/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_786_expect_error_shadow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_816.ts b/crates/interpreter/tests/fixtures/narrowing/issue_816.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_816.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_816.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_889.ts b/crates/interpreter/tests/fixtures/narrowing/issue_889.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_889.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_889.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts b/crates/interpreter/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_889_expect_error_arrow_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_890_anonymous_lift.ts b/crates/interpreter/tests/fixtures/narrowing/issue_890_anonymous_lift.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_890_anonymous_lift.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_890_anonymous_lift.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_890_predicate_lift.ts b/crates/interpreter/tests/fixtures/narrowing/issue_890_predicate_lift.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_890_predicate_lift.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_890_predicate_lift.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_929.ts b/crates/interpreter/tests/fixtures/narrowing/issue_929.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_929.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_929.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_929_expect_error_union.ts b/crates/interpreter/tests/fixtures/narrowing/issue_929_expect_error_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_929_expect_error_union.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_929_expect_error_union.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948_composed.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948_composed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948_composed.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948_composed.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948_discriminant.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948_discriminant.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948_discriminant.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948_discriminant.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948_nested.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948_nested.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948_nested.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948_nested.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948_switch.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948_switch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948_switch.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948_switch.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/issue_948_union_refined.ts b/crates/interpreter/tests/fixtures/narrowing/issue_948_union_refined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/issue_948_union_refined.ts rename to crates/interpreter/tests/fixtures/narrowing/issue_948_union_refined.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/join_points_keep_narrowing.ts b/crates/interpreter/tests/fixtures/narrowing/join_points_keep_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/join_points_keep_narrowing.ts rename to crates/interpreter/tests/fixtures/narrowing/join_points_keep_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts b/crates/interpreter/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts rename to crates/interpreter/tests/fixtures/narrowing/literal_equality_chain_rules_out.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts b/crates/interpreter/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts rename to crates/interpreter/tests/fixtures/narrowing/literal_equality_excludes_nullish.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/literal_index_guard.ts b/crates/interpreter/tests/fixtures/narrowing/literal_index_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/literal_index_guard.ts rename to crates/interpreter/tests/fixtures/narrowing/literal_index_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_assignment_result.ts b/crates/interpreter/tests/fixtures/narrowing/live_assignment_result.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_assignment_result.ts rename to crates/interpreter/tests/fixtures/narrowing/live_assignment_result.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_big_bom.ts b/crates/interpreter/tests/fixtures/narrowing/live_big_bom.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_big_bom.ts rename to crates/interpreter/tests/fixtures/narrowing/live_big_bom.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_big_separator.ts b/crates/interpreter/tests/fixtures/narrowing/live_big_separator.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_big_separator.ts rename to crates/interpreter/tests/fixtures/narrowing/live_big_separator.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_boolean_literal_result.ts b/crates/interpreter/tests/fixtures/narrowing/live_boolean_literal_result.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_boolean_literal_result.ts rename to crates/interpreter/tests/fixtures/narrowing/live_boolean_literal_result.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_call_order.ts b/crates/interpreter/tests/fixtures/narrowing/live_call_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_call_order.ts rename to crates/interpreter/tests/fixtures/narrowing/live_call_order.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_function_reference.ts b/crates/interpreter/tests/fixtures/narrowing/live_function_reference.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_function_reference.ts rename to crates/interpreter/tests/fixtures/narrowing/live_function_reference.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_index_conversion.ts b/crates/interpreter/tests/fixtures/narrowing/live_index_conversion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_index_conversion.ts rename to crates/interpreter/tests/fixtures/narrowing/live_index_conversion.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_index_noncanonical.ts b/crates/interpreter/tests/fixtures/narrowing/live_index_noncanonical.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_index_noncanonical.ts rename to crates/interpreter/tests/fixtures/narrowing/live_index_noncanonical.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_json_arguments.ts b/crates/interpreter/tests/fixtures/narrowing/live_json_arguments.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_json_arguments.ts rename to crates/interpreter/tests/fixtures/narrowing/live_json_arguments.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_map_return.ts b/crates/interpreter/tests/fixtures/narrowing/live_map_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_map_return.ts rename to crates/interpreter/tests/fixtures/narrowing/live_map_return.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_builtin_rest.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_builtin_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_builtin_rest.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_builtin_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_class_rest.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_class_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_class_rest.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_class_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_default.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_default.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_default.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_fresh_default.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_fresh_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_fresh_default.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_fresh_default.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_function_default.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_function_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_function_default.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_function_default.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_member_rest.ts b/crates/interpreter/tests/fixtures/narrowing/live_member_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_member_rest.ts rename to crates/interpreter/tests/fixtures/narrowing/live_member_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_number_predicate.ts b/crates/interpreter/tests/fixtures/narrowing/live_number_predicate.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_number_predicate.ts rename to crates/interpreter/tests/fixtures/narrowing/live_number_predicate.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_optional_shape_analysis.ts b/crates/interpreter/tests/fixtures/narrowing/live_optional_shape_analysis.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_optional_shape_analysis.ts rename to crates/interpreter/tests/fixtures/narrowing/live_optional_shape_analysis.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_array_argument/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_array_argument/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_callback_parameter/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_function_reference/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_function_reference/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_imported_global/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_imported_global/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_object_argument/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_object_argument/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_returned_closure/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_package_setter_parameter/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_postfix_value.ts b/crates/interpreter/tests/fixtures/narrowing/live_postfix_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_postfix_value.ts rename to crates/interpreter/tests/fixtures/narrowing/live_postfix_value.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_pow_boundary.ts b/crates/interpreter/tests/fixtures/narrowing/live_pow_boundary.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_pow_boundary.ts rename to crates/interpreter/tests/fixtures/narrowing/live_pow_boundary.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_pow_nan.ts b/crates/interpreter/tests/fixtures/narrowing/live_pow_nan.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_pow_nan.ts rename to crates/interpreter/tests/fixtures/narrowing/live_pow_nan.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_generic.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_generic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_generic.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_generic.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_includes.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_includes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_includes.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_includes.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_length.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_length.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_length.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_length.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_method.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_method.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_method.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_optional.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_optional.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_receiver_to_string.ts b/crates/interpreter/tests/fixtures/narrowing/live_receiver_to_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_receiver_to_string.ts rename to crates/interpreter/tests/fixtures/narrowing/live_receiver_to_string.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_regex_argument.ts b/crates/interpreter/tests/fixtures/narrowing/live_regex_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_regex_argument.ts rename to crates/interpreter/tests/fixtures/narrowing/live_regex_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_runtime_values.ts b/crates/interpreter/tests/fixtures/narrowing/live_runtime_values.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_runtime_values.ts rename to crates/interpreter/tests/fixtures/narrowing/live_runtime_values.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_search_order.ts b/crates/interpreter/tests/fixtures/narrowing/live_search_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_search_order.ts rename to crates/interpreter/tests/fixtures/narrowing/live_search_order.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_string_argument.ts b/crates/interpreter/tests/fixtures/narrowing/live_string_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_string_argument.ts rename to crates/interpreter/tests/fixtures/narrowing/live_string_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_valueof_conversion.ts b/crates/interpreter/tests/fixtures/narrowing/live_valueof_conversion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_valueof_conversion.ts rename to crates/interpreter/tests/fixtures/narrowing/live_valueof_conversion.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/app/main.ts b/crates/interpreter/tests/fixtures/narrowing/live_values_packages/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/app/main.ts rename to crates/interpreter/tests/fixtures/narrowing/live_values_packages/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/library/lib.ts b/crates/interpreter/tests/fixtures/narrowing/live_values_packages/library/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/library/lib.ts rename to crates/interpreter/tests/fixtures/narrowing/live_values_packages/library/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/packages.manifest b/crates/interpreter/tests/fixtures/narrowing/live_values_packages/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/live_values_packages/packages.manifest rename to crates/interpreter/tests/fixtures/narrowing/live_values_packages/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/narrowing/loop_exit_body_local_join.ts b/crates/interpreter/tests/fixtures/narrowing/loop_exit_body_local_join.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/loop_exit_body_local_join.ts rename to crates/interpreter/tests/fixtures/narrowing/loop_exit_body_local_join.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts b/crates/interpreter/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts rename to crates/interpreter/tests/fixtures/narrowing/loop_head_keeps_narrowing_when_body_returns.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/loop_join_after_continue.ts b/crates/interpreter/tests/fixtures/narrowing/loop_join_after_continue.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/loop_join_after_continue.ts rename to crates/interpreter/tests/fixtures/narrowing/loop_join_after_continue.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/loop_tail_narrowings.ts b/crates/interpreter/tests/fixtures/narrowing/loop_tail_narrowings.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/loop_tail_narrowings.ts rename to crates/interpreter/tests/fixtures/narrowing/loop_tail_narrowings.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/loop_wrapped_body_forms.ts b/crates/interpreter/tests/fixtures/narrowing/loop_wrapped_body_forms.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/loop_wrapped_body_forms.ts rename to crates/interpreter/tests/fixtures/narrowing/loop_wrapped_body_forms.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm b/crates/interpreter/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm rename to crates/interpreter/tests/fixtures/narrowing/mixed_union_typeof_plus_kind.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts b/crates/interpreter/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts rename to crates/interpreter/tests/fixtures/narrowing/module_let_written_by_function_narrows_within_statement.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/nested_block_narrowing.subm b/crates/interpreter/tests/fixtures/narrowing/nested_block_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/nested_block_narrowing.subm rename to crates/interpreter/tests/fixtures/narrowing/nested_block_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/nested_shadow_reuse.ts b/crates/interpreter/tests/fixtures/narrowing/nested_shadow_reuse.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/nested_shadow_reuse.ts rename to crates/interpreter/tests/fixtures/narrowing/nested_shadow_reuse.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/never_array_hints_later_elements.ts b/crates/interpreter/tests/fixtures/narrowing/never_array_hints_later_elements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/never_array_hints_later_elements.ts rename to crates/interpreter/tests/fixtures/narrowing/never_array_hints_later_elements.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/never_field_in_object_literal.ts b/crates/interpreter/tests/fixtures/narrowing/never_field_in_object_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/never_field_in_object_literal.ts rename to crates/interpreter/tests/fixtures/narrowing/never_field_in_object_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/never_operand_in_dead_code.ts b/crates/interpreter/tests/fixtures/narrowing/never_operand_in_dead_code.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/never_operand_in_dead_code.ts rename to crates/interpreter/tests/fixtures/narrowing/never_operand_in_dead_code.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/never_read_in_closure.ts b/crates/interpreter/tests/fixtures/narrowing/never_read_in_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/never_read_in_closure.ts rename to crates/interpreter/tests/fixtures/narrowing/never_read_in_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/nominal_union_field_access.ts b/crates/interpreter/tests/fixtures/narrowing/nominal_union_field_access.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/nominal_union_field_access.ts rename to crates/interpreter/tests/fixtures/narrowing/nominal_union_field_access.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/non_null_assertion.ts b/crates/interpreter/tests/fixtures/narrowing/non_null_assertion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/non_null_assertion.ts rename to crates/interpreter/tests/fixtures/narrowing/non_null_assertion.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts b/crates/interpreter/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts rename to crates/interpreter/tests/fixtures/narrowing/non_null_receiver_preserves_path.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/not_truthiness_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/not_truthiness_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/not_truthiness_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/not_truthiness_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/null_comparison_guards.ts b/crates/interpreter/tests/fixtures/narrowing/null_comparison_guards.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/null_comparison_guards.ts rename to crates/interpreter/tests/fixtures/narrowing/null_comparison_guards.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/null_eq_else.subm b/crates/interpreter/tests/fixtures/narrowing/null_eq_else.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/null_eq_else.subm rename to crates/interpreter/tests/fixtures/narrowing/null_eq_else.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/null_global_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/null_global_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/null_global_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/null_global_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/null_neq_then.subm b/crates/interpreter/tests/fixtures/narrowing/null_neq_then.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/null_neq_then.subm rename to crates/interpreter/tests/fixtures/narrowing/null_neq_then.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/null_neq_unbox.subm b/crates/interpreter/tests/fixtures/narrowing/null_neq_unbox.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/null_neq_unbox.subm rename to crates/interpreter/tests/fixtures/narrowing/null_neq_unbox.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/nullable_rw_target_write_out.ts b/crates/interpreter/tests/fixtures/narrowing/nullable_rw_target_write_out.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/nullable_rw_target_write_out.ts rename to crates/interpreter/tests/fixtures/narrowing/nullable_rw_target_write_out.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/nullable_smoke.subm b/crates/interpreter/tests/fixtures/narrowing/nullable_smoke.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/nullable_smoke.subm rename to crates/interpreter/tests/fixtures/narrowing/nullable_smoke.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/operator_narrowing.ts b/crates/interpreter/tests/fixtures/narrowing/operator_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/operator_narrowing.ts rename to crates/interpreter/tests/fixtures/narrowing/operator_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm b/crates/interpreter/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm rename to crates/interpreter/tests/fixtures/narrowing/optional_field_eq_null_post_if.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm b/crates/interpreter/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm rename to crates/interpreter/tests/fixtures/narrowing/optional_field_neq_null_narrows.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/postfix_narrowed.ts b/crates/interpreter/tests/fixtures/narrowing/postfix_narrowed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/postfix_narrowed.ts rename to crates/interpreter/tests/fixtures/narrowing/postfix_narrowed.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_chained_post_if.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_chained_post_if.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_chained_post_if.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_chained_post_if.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_post_if.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_post_if.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_post_if.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_post_if.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_three_variants.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_discriminant_view_on_field.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_eq_else.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_eq_else.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_eq_else.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_eq_else.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_neq_then.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_neq_then.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then_post_if.subm b/crates/interpreter/tests/fixtures/narrowing/property_path_neq_then_post_if.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/property_path_neq_then_post_if.subm rename to crates/interpreter/tests/fixtures/narrowing/property_path_neq_then_post_if.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/reassign_same_type_rewidens.ts b/crates/interpreter/tests/fixtures/narrowing/reassign_same_type_rewidens.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/reassign_same_type_rewidens.ts rename to crates/interpreter/tests/fixtures/narrowing/reassign_same_type_rewidens.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/return_in_if_carries_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/return_in_if_carries_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/return_in_if_carries_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/return_in_if_carries_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/rules_out_every_value.ts b/crates/interpreter/tests/fixtures/narrowing/rules_out_every_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/rules_out_every_value.ts rename to crates/interpreter/tests/fixtures/narrowing/rules_out_every_value.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/short_circuit_and_narrows.subm b/crates/interpreter/tests/fixtures/narrowing/short_circuit_and_narrows.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/short_circuit_and_narrows.subm rename to crates/interpreter/tests/fixtures/narrowing/short_circuit_and_narrows.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/short_circuit_or_narrows.subm b/crates/interpreter/tests/fixtures/narrowing/short_circuit_or_narrows.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/short_circuit_or_narrows.subm rename to crates/interpreter/tests/fixtures/narrowing/short_circuit_or_narrows.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts b/crates/interpreter/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts rename to crates/interpreter/tests/fixtures/narrowing/sibling_paths_mixed_chain_len.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_three_idents.ts b/crates/interpreter/tests/fixtures/narrowing/sibling_paths_three_idents.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/sibling_paths_three_idents.ts rename to crates/interpreter/tests/fixtures/narrowing/sibling_paths_three_idents.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/switch_boolean_discriminant.ts b/crates/interpreter/tests/fixtures/narrowing/switch_boolean_discriminant.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/switch_boolean_discriminant.ts rename to crates/interpreter/tests/fixtures/narrowing/switch_boolean_discriminant.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts b/crates/interpreter/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts rename to crates/interpreter/tests/fixtures/narrowing/switch_default_reads_never_on_any_path.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts b/crates/interpreter/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts rename to crates/interpreter/tests/fixtures/narrowing/switch_wide_discriminant_falls_through.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/switch_without_default_falls_through.ts b/crates/interpreter/tests/fixtures/narrowing/switch_without_default_falls_through.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/switch_without_default_falls_through.ts rename to crates/interpreter/tests/fixtures/narrowing/switch_without_default_falls_through.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/ternary_and_interface_field.ts b/crates/interpreter/tests/fixtures/narrowing/ternary_and_interface_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/ternary_and_interface_field.ts rename to crates/interpreter/tests/fixtures/narrowing/ternary_and_interface_field.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/this_rooted_paths.ts b/crates/interpreter/tests/fixtures/narrowing/this_rooted_paths.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/this_rooted_paths.ts rename to crates/interpreter/tests/fixtures/narrowing/this_rooted_paths.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/throw_in_if_carries_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/truthiness_field_path_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/truthiness_field_path_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/truthiness_field_path_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/truthiness_field_path_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/truthiness_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/truthiness_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/truthiness_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/truthiness_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm b/crates/interpreter/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm rename to crates/interpreter/tests/fixtures/narrowing/tuple_union_literal_discriminator.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm b/crates/interpreter/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm rename to crates/interpreter/tests/fixtures/narrowing/tuple_union_typeof_discriminator.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_aliased_union.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_aliased_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_aliased_union.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_aliased_union.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_boolean_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_boolean_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_boolean_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_boolean_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_else_branch.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_field_path_else_branch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_else_branch.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_field_path_else_branch.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_string.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_field_path_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_field_path_string.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_field_path_string.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts b/crates/interpreter/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts rename to crates/interpreter/tests/fixtures/narrowing/typeof_folded_operand_still_runs.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_function_generic.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_function_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_function_generic.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_function_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_function_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_function_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_function_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_function_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_number_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_number_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_number_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_number_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts b/crates/interpreter/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts rename to crates/interpreter/tests/fixtures/narrowing/typeof_object_and_enum_tags.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_generic.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_object_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_object_generic.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_object_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_object_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_object_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_object_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_object_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_string_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_string_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_string_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_string_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_three_way_union.subm b/crates/interpreter/tests/fixtures/narrowing/typeof_three_way_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_three_way_union.subm rename to crates/interpreter/tests/fixtures/narrowing/typeof_three_way_union.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/typeof_through_generic_alias.ts b/crates/interpreter/tests/fixtures/narrowing/typeof_through_generic_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/typeof_through_generic_alias.ts rename to crates/interpreter/tests/fixtures/narrowing/typeof_through_generic_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_discriminant.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_discriminant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_discriminant.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_discriminant.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_else_branch.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_else_branch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_else_branch.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_else_branch.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_generic_non_generic_asserted.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_strip_null.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_generic_strip_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_generic_strip_null.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_generic_strip_null.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_in_typeof.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_in_typeof.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_in_typeof.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_in_typeof.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_nullable.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_nullable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_nullable.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_nullable.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_primitive.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_primitive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_primitive.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_primitive.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/user_guard_type_alias.subm b/crates/interpreter/tests/fixtures/narrowing/user_guard_type_alias.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/user_guard_type_alias.subm rename to crates/interpreter/tests/fixtures/narrowing/user_guard_type_alias.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_body_local_continue_narrow.ts b/crates/interpreter/tests/fixtures/narrowing/while_body_local_continue_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_body_local_continue_narrow.ts rename to crates/interpreter/tests/fixtures/narrowing/while_body_local_continue_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_body_narrowing.subm b/crates/interpreter/tests/fixtures/narrowing/while_body_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_body_narrowing.subm rename to crates/interpreter/tests/fixtures/narrowing/while_body_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_break_carries_narrow.subm b/crates/interpreter/tests/fixtures/narrowing/while_break_carries_narrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_break_carries_narrow.subm rename to crates/interpreter/tests/fixtures/narrowing/while_break_carries_narrow.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_break_two_paths_widens.subm b/crates/interpreter/tests/fixtures/narrowing/while_break_two_paths_widens.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_break_two_paths_widens.subm rename to crates/interpreter/tests/fixtures/narrowing/while_break_two_paths_widens.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_continue.subm b/crates/interpreter/tests/fixtures/narrowing/while_fixed_point_continue.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_continue.subm rename to crates/interpreter/tests/fixtures/narrowing/while_fixed_point_continue.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_converges.subm b/crates/interpreter/tests/fixtures/narrowing/while_fixed_point_converges.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing/while_fixed_point_converges.subm rename to crates/interpreter/tests/fixtures/narrowing/while_fixed_point_converges.subm diff --git a/crates/submilli-engine/tests/fixtures/narrowing_field_path_nested_region.ts b/crates/interpreter/tests/fixtures/narrowing_field_path_nested_region.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/narrowing_field_path_nested_region.ts rename to crates/interpreter/tests/fixtures/narrowing_field_path_nested_region.ts diff --git a/crates/submilli-engine/tests/fixtures/nested_function_default_param.ts b/crates/interpreter/tests/fixtures/nested_function_default_param.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nested_function_default_param.ts rename to crates/interpreter/tests/fixtures/nested_function_default_param.ts diff --git a/crates/submilli-engine/tests/fixtures/nested_function_reads_later_local.ts b/crates/interpreter/tests/fixtures/nested_function_reads_later_local.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nested_function_reads_later_local.ts rename to crates/interpreter/tests/fixtures/nested_function_reads_later_local.ts diff --git a/crates/submilli-engine/tests/fixtures/nested_function_top_level_block.ts b/crates/interpreter/tests/fixtures/nested_function_top_level_block.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nested_function_top_level_block.ts rename to crates/interpreter/tests/fixtures/nested_function_top_level_block.ts diff --git a/crates/submilli-engine/tests/fixtures/never/expect_error_never_falls_through.subm b/crates/interpreter/tests/fixtures/never/expect_error_never_falls_through.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/expect_error_never_falls_through.subm rename to crates/interpreter/tests/fixtures/never/expect_error_never_falls_through.subm diff --git a/crates/submilli-engine/tests/fixtures/never/expect_error_return_value_in_never_fn.subm b/crates/interpreter/tests/fixtures/never/expect_error_return_value_in_never_fn.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/expect_error_return_value_in_never_fn.subm rename to crates/interpreter/tests/fixtures/never/expect_error_return_value_in_never_fn.subm diff --git a/crates/submilli-engine/tests/fixtures/never/expect_error_value_into_never_slot.subm b/crates/interpreter/tests/fixtures/never/expect_error_value_into_never_slot.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/expect_error_value_into_never_slot.subm rename to crates/interpreter/tests/fixtures/never/expect_error_value_into_never_slot.subm diff --git a/crates/submilli-engine/tests/fixtures/never/never_assignable_to_string.subm b/crates/interpreter/tests/fixtures/never/never_assignable_to_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/never_assignable_to_string.subm rename to crates/interpreter/tests/fixtures/never/never_assignable_to_string.subm diff --git a/crates/submilli-engine/tests/fixtures/never/never_in_union.subm b/crates/interpreter/tests/fixtures/never/never_in_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/never_in_union.subm rename to crates/interpreter/tests/fixtures/never/never_in_union.subm diff --git a/crates/submilli-engine/tests/fixtures/never/never_return_throw.subm b/crates/interpreter/tests/fixtures/never/never_return_throw.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/never/never_return_throw.subm rename to crates/interpreter/tests/fixtures/never/never_return_throw.subm diff --git a/crates/submilli-engine/tests/fixtures/never_annotated_closure_in_void_slot.ts b/crates/interpreter/tests/fixtures/never_annotated_closure_in_void_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/never_annotated_closure_in_void_slot.ts rename to crates/interpreter/tests/fixtures/never_annotated_closure_in_void_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/never_function_void_slot.ts b/crates/interpreter/tests/fixtures/never_function_void_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/never_function_void_slot.ts rename to crates/interpreter/tests/fixtures/never_function_void_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/never_generic_callback.ts b/crates/interpreter/tests/fixtures/never_generic_callback.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/never_generic_callback.ts rename to crates/interpreter/tests/fixtures/never_generic_callback.ts diff --git a/crates/submilli-engine/tests/fixtures/never_operands.ts b/crates/interpreter/tests/fixtures/never_operands.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/never_operands.ts rename to crates/interpreter/tests/fixtures/never_operands.ts diff --git a/crates/submilli-engine/tests/fixtures/new_uint8array.subm b/crates/interpreter/tests/fixtures/new_uint8array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/new_uint8array.subm rename to crates/interpreter/tests/fixtures/new_uint8array.subm diff --git a/crates/submilli-engine/tests/fixtures/new_with_dotted_form.subm b/crates/interpreter/tests/fixtures/new_with_dotted_form.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/new_with_dotted_form.subm rename to crates/interpreter/tests/fixtures/new_with_dotted_form.subm diff --git a/crates/submilli-engine/tests/fixtures/no_panic_prelude_invariants.ts b/crates/interpreter/tests/fixtures/no_panic_prelude_invariants.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/no_panic_prelude_invariants.ts rename to crates/interpreter/tests/fixtures/no_panic_prelude_invariants.ts diff --git a/crates/submilli-engine/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts b/crates/interpreter/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts rename to crates/interpreter/tests/fixtures/non_null_assert_on_null_narrowing_reads_declared.ts diff --git a/crates/submilli-engine/tests/fixtures/null_discriminant_narrows.ts b/crates/interpreter/tests/fixtures/null_discriminant_narrows.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/null_discriminant_narrows.ts rename to crates/interpreter/tests/fixtures/null_discriminant_narrows.ts diff --git a/crates/submilli-engine/tests/fixtures/nullable_receiver_names_the_guard.ts b/crates/interpreter/tests/fixtures/nullable_receiver_names_the_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullable_receiver_names_the_guard.ts rename to crates/interpreter/tests/fixtures/nullable_receiver_names_the_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/chained.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/chained.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/chained.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/chained.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts b/crates/interpreter/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts rename to crates/interpreter/tests/fixtures/nullish_coalescing/coalesce_null_typed_left.ts diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_and.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/expect_error_mix_with_or.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/simple.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/simple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/simple.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/simple.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/void_right.ts b/crates/interpreter/tests/fixtures/nullish_coalescing/void_right.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/void_right.ts rename to crates/interpreter/tests/fixtures/nullish_coalescing/void_right.ts diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/with_field.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/with_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/with_field.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/with_field.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_coalescing/with_parens_ok.subm b/crates/interpreter/tests/fixtures/nullish_coalescing/with_parens_ok.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_coalescing/with_parens_ok.subm rename to crates/interpreter/tests/fixtures/nullish_coalescing/with_parens_ok.subm diff --git a/crates/submilli-engine/tests/fixtures/nullish_grouping_and_zero_literals.ts b/crates/interpreter/tests/fixtures/nullish_grouping_and_zero_literals.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/nullish_grouping_and_zero_literals.ts rename to crates/interpreter/tests/fixtures/nullish_grouping_and_zero_literals.ts diff --git a/crates/submilli-engine/tests/fixtures/number_global_predicates.subm b/crates/interpreter/tests/fixtures/number_global_predicates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_global_predicates.subm rename to crates/interpreter/tests/fixtures/number_global_predicates.subm diff --git a/crates/submilli-engine/tests/fixtures/number_parse_statics.subm b/crates/interpreter/tests/fixtures/number_parse_statics.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_parse_statics.subm rename to crates/interpreter/tests/fixtures/number_parse_statics.subm diff --git a/crates/submilli-engine/tests/fixtures/number_predicates_no_coercion.ts b/crates/interpreter/tests/fixtures/number_predicates_no_coercion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_predicates_no_coercion.ts rename to crates/interpreter/tests/fixtures/number_predicates_no_coercion.ts diff --git a/crates/submilli-engine/tests/fixtures/number_radix_strings.subm b/crates/interpreter/tests/fixtures/number_radix_strings.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_radix_strings.subm rename to crates/interpreter/tests/fixtures/number_radix_strings.subm diff --git a/crates/submilli-engine/tests/fixtures/number_static_constants.subm b/crates/interpreter/tests/fixtures/number_static_constants.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_static_constants.subm rename to crates/interpreter/tests/fixtures/number_static_constants.subm diff --git a/crates/submilli-engine/tests/fixtures/number_static_predicates.subm b/crates/interpreter/tests/fixtures/number_static_predicates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_static_predicates.subm rename to crates/interpreter/tests/fixtures/number_static_predicates.subm diff --git a/crates/submilli-engine/tests/fixtures/number_to_fixed.subm b/crates/interpreter/tests/fixtures/number_to_fixed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_to_fixed.subm rename to crates/interpreter/tests/fixtures/number_to_fixed.subm diff --git a/crates/submilli-engine/tests/fixtures/number_to_precision_exponential.subm b/crates/interpreter/tests/fixtures/number_to_precision_exponential.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_to_precision_exponential.subm rename to crates/interpreter/tests/fixtures/number_to_precision_exponential.subm diff --git a/crates/submilli-engine/tests/fixtures/number_to_string_radix.subm b/crates/interpreter/tests/fixtures/number_to_string_radix.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/number_to_string_radix.subm rename to crates/interpreter/tests/fixtures/number_to_string_radix.subm diff --git a/crates/submilli-engine/tests/fixtures/numeric_separators_and_decimal_point.ts b/crates/interpreter/tests/fixtures/numeric_separators_and_decimal_point.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/numeric_separators_and_decimal_point.ts rename to crates/interpreter/tests/fixtures/numeric_separators_and_decimal_point.ts diff --git a/crates/submilli-engine/tests/fixtures/object_function_typed_field.subm b/crates/interpreter/tests/fixtures/object_function_typed_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_function_typed_field.subm rename to crates/interpreter/tests/fixtures/object_function_typed_field.subm diff --git a/crates/submilli-engine/tests/fixtures/object_is.subm b/crates/interpreter/tests/fixtures/object_is.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_is.subm rename to crates/interpreter/tests/fixtures/object_is.subm diff --git a/crates/submilli-engine/tests/fixtures/object_key_reassigned_wider_field.ts b/crates/interpreter/tests/fixtures/object_key_reassigned_wider_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_key_reassigned_wider_field.ts rename to crates/interpreter/tests/fixtures/object_key_reassigned_wider_field.ts diff --git a/crates/submilli-engine/tests/fixtures/object_literal_dictionary_union.ts b/crates/interpreter/tests/fixtures/object_literal_dictionary_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_literal_dictionary_union.ts rename to crates/interpreter/tests/fixtures/object_literal_dictionary_union.ts diff --git a/crates/submilli-engine/tests/fixtures/object_literal_evaluation_order.ts b/crates/interpreter/tests/fixtures/object_literal_evaluation_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_literal_evaluation_order.ts rename to crates/interpreter/tests/fixtures/object_literal_evaluation_order.ts diff --git a/crates/submilli-engine/tests/fixtures/object_literal_into_nullable_tagged_union.ts b/crates/interpreter/tests/fixtures/object_literal_into_nullable_tagged_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_literal_into_nullable_tagged_union.ts rename to crates/interpreter/tests/fixtures/object_literal_into_nullable_tagged_union.ts diff --git a/crates/submilli-engine/tests/fixtures/object_literal_normalization_at_depth.ts b/crates/interpreter/tests/fixtures/object_literal_normalization_at_depth.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_literal_normalization_at_depth.ts rename to crates/interpreter/tests/fixtures/object_literal_normalization_at_depth.ts diff --git a/crates/submilli-engine/tests/fixtures/object_literal_subtype_reduction.ts b/crates/interpreter/tests/fixtures/object_literal_subtype_reduction.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_literal_subtype_reduction.ts rename to crates/interpreter/tests/fixtures/object_literal_subtype_reduction.ts diff --git a/crates/submilli-engine/tests/fixtures/object_rest_copies.ts b/crates/interpreter/tests/fixtures/object_rest_copies.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_rest_copies.ts rename to crates/interpreter/tests/fixtures/object_rest_copies.ts diff --git a/crates/submilli-engine/tests/fixtures/object_rest_let.ts b/crates/interpreter/tests/fixtures/object_rest_let.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_rest_let.ts rename to crates/interpreter/tests/fixtures/object_rest_let.ts diff --git a/crates/submilli-engine/tests/fixtures/object_spread_widened_union.ts b/crates/interpreter/tests/fixtures/object_spread_widened_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_spread_widened_union.ts rename to crates/interpreter/tests/fixtures/object_spread_widened_union.ts diff --git a/crates/submilli-engine/tests/fixtures/object_statics.subm b/crates/interpreter/tests/fixtures/object_statics.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_statics.subm rename to crates/interpreter/tests/fixtures/object_statics.subm diff --git a/crates/submilli-engine/tests/fixtures/object_statics_host.ts b/crates/interpreter/tests/fixtures/object_statics_host.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_statics_host.ts rename to crates/interpreter/tests/fixtures/object_statics_host.ts diff --git a/crates/submilli-engine/tests/fixtures/object_type_member_named_new.ts b/crates/interpreter/tests/fixtures/object_type_member_named_new.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/object_type_member_named_new.ts rename to crates/interpreter/tests/fixtures/object_type_member_named_new.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts b/crates/interpreter/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts rename to crates/interpreter/tests/fixtures/objects/absent_optional_property_with_sibling_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_missing_field.subm b/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_missing_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_missing_field.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_field_assign_missing_field.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_non_object.subm b/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_non_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_non_object.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_field_assign_non_object.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm b/crates/interpreter/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_field_assign_type_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm b/crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_annotated.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm b/crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_fresh_literal_extra_return.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_invalid_assign_target.subm b/crates/interpreter/tests/fixtures/objects/expect_error_invalid_assign_target.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_invalid_assign_target.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_invalid_assign_target.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm b/crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_required.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm b/crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_optional_not_assignable_to_value_nullable.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_union_missing_field.subm b/crates/interpreter/tests/fixtures/objects/expect_error_union_missing_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_union_missing_field.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_union_missing_field.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm b/crates/interpreter/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_unknown_string_bracket_field.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm b/crates/interpreter/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm rename to crates/interpreter/tests/fixtures/objects/expect_error_value_nullable_not_assignable_to_optional.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/field_assign_basic.subm b/crates/interpreter/tests/fixtures/objects/field_assign_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/field_assign_basic.subm rename to crates/interpreter/tests/fixtures/objects/field_assign_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/field_assign_const_binding.subm b/crates/interpreter/tests/fixtures/objects/field_assign_const_binding.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/field_assign_const_binding.subm rename to crates/interpreter/tests/fixtures/objects/field_assign_const_binding.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/field_assign_nested.subm b/crates/interpreter/tests/fixtures/objects/field_assign_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/field_assign_nested.subm rename to crates/interpreter/tests/fixtures/objects/field_assign_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/field_assign_string.subm b/crates/interpreter/tests/fixtures/objects/field_assign_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/field_assign_string.subm rename to crates/interpreter/tests/fixtures/objects/field_assign_string.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/interface_field_assignment.ts b/crates/interpreter/tests/fixtures/objects/interface_field_assignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/interface_field_assignment.ts rename to crates/interpreter/tests/fixtures/objects/interface_field_assignment.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/interface_property_write_dispatch.ts b/crates/interpreter/tests/fixtures/objects/interface_property_write_dispatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/interface_property_write_dispatch.ts rename to crates/interpreter/tests/fixtures/objects/interface_property_write_dispatch.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/multiline_object_literal.subm b/crates/interpreter/tests/fixtures/objects/multiline_object_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/multiline_object_literal.subm rename to crates/interpreter/tests/fixtures/objects/multiline_object_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/nullable_eq_literal.subm b/crates/interpreter/tests/fixtures/objects/nullable_eq_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/nullable_eq_literal.subm rename to crates/interpreter/tests/fixtures/objects/nullable_eq_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/nullable_field_literal.subm b/crates/interpreter/tests/fixtures/objects/nullable_field_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/nullable_field_literal.subm rename to crates/interpreter/tests/fixtures/objects/nullable_field_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/optional_field_literal.subm b/crates/interpreter/tests/fixtures/objects/optional_field_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/optional_field_literal.subm rename to crates/interpreter/tests/fixtures/objects/optional_field_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/optional_field_null_compare.subm b/crates/interpreter/tests/fixtures/objects/optional_field_null_compare.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/optional_field_null_compare.subm rename to crates/interpreter/tests/fixtures/objects/optional_field_null_compare.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/optional_present_null.ts b/crates/interpreter/tests/fixtures/objects/optional_present_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/optional_present_null.ts rename to crates/interpreter/tests/fixtures/objects/optional_present_null.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/optional_undefined_presence.ts b/crates/interpreter/tests/fixtures/objects/optional_undefined_presence.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/optional_undefined_presence.ts rename to crates/interpreter/tests/fixtures/objects/optional_undefined_presence.ts diff --git a/crates/submilli-engine/tests/fixtures/objects/property_shorthand.subm b/crates/interpreter/tests/fixtures/objects/property_shorthand.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/property_shorthand.subm rename to crates/interpreter/tests/fixtures/objects/property_shorthand.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/quoted_property_names.subm b/crates/interpreter/tests/fixtures/objects/quoted_property_names.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/quoted_property_names.subm rename to crates/interpreter/tests/fixtures/objects/quoted_property_names.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/reserved_keyword_property_names.subm b/crates/interpreter/tests/fixtures/objects/reserved_keyword_property_names.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/reserved_keyword_property_names.subm rename to crates/interpreter/tests/fixtures/objects/reserved_keyword_property_names.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/union_field_access.subm b/crates/interpreter/tests/fixtures/objects/union_field_access.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/union_field_access.subm rename to crates/interpreter/tests/fixtures/objects/union_field_access.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/widen_to_nullable_field.subm b/crates/interpreter/tests/fixtures/objects/widen_to_nullable_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/widen_to_nullable_field.subm rename to crates/interpreter/tests/fixtures/objects/widen_to_nullable_field.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/width_sub_array.subm b/crates/interpreter/tests/fixtures/objects/width_sub_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/width_sub_array.subm rename to crates/interpreter/tests/fixtures/objects/width_sub_array.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/width_sub_assign.subm b/crates/interpreter/tests/fixtures/objects/width_sub_assign.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/width_sub_assign.subm rename to crates/interpreter/tests/fixtures/objects/width_sub_assign.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/width_sub_basic.subm b/crates/interpreter/tests/fixtures/objects/width_sub_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/width_sub_basic.subm rename to crates/interpreter/tests/fixtures/objects/width_sub_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/width_sub_intermediate_arg.subm b/crates/interpreter/tests/fixtures/objects/width_sub_intermediate_arg.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/width_sub_intermediate_arg.subm rename to crates/interpreter/tests/fixtures/objects/width_sub_intermediate_arg.subm diff --git a/crates/submilli-engine/tests/fixtures/objects/width_sub_nested.subm b/crates/interpreter/tests/fixtures/objects/width_sub_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/objects/width_sub_nested.subm rename to crates/interpreter/tests/fixtures/objects/width_sub_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chain_near_limit.ts b/crates/interpreter/tests/fixtures/optional_chain_near_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chain_near_limit.ts rename to crates/interpreter/tests/fixtures/optional_chain_near_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chain_non_nullable_receiver.ts b/crates/interpreter/tests/fixtures/optional_chain_non_nullable_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chain_non_nullable_receiver.ts rename to crates/interpreter/tests/fixtures/optional_chain_non_nullable_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chain_nullable_host_property.ts b/crates/interpreter/tests/fixtures/optional_chain_nullable_host_property.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chain_nullable_host_property.ts rename to crates/interpreter/tests/fixtures/optional_chain_nullable_host_property.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chain_string_key.ts b/crates/interpreter/tests/fixtures/optional_chain_string_key.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chain_string_key.ts rename to crates/interpreter/tests/fixtures/optional_chain_string_key.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts b/crates/interpreter/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts rename to crates/interpreter/tests/fixtures/optional_chaining/chain_nullable_step_fixes.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/chain_then_coalesce.subm b/crates/interpreter/tests/fixtures/optional_chaining/chain_then_coalesce.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/chain_then_coalesce.subm rename to crates/interpreter/tests/fixtures/optional_chaining/chain_then_coalesce.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts b/crates/interpreter/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts rename to crates/interpreter/tests/fixtures/optional_chaining/expect_error_chain_nullable_step.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts b/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts rename to crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_call_binding.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts b/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts rename to crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_method_reference.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts b/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts rename to crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_null_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts b/crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts rename to crates/interpreter/tests/fixtures/optional_chaining/expect_error_optional_unknown_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/field_chain.subm b/crates/interpreter/tests/fixtures/optional_chaining/field_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/field_chain.subm rename to crates/interpreter/tests/fixtures/optional_chaining/field_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/multiple_optional.subm b/crates/interpreter/tests/fixtures/optional_chaining/multiple_optional.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/multiple_optional.subm rename to crates/interpreter/tests/fixtures/optional_chaining/multiple_optional.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/nested_field_chain.subm b/crates/interpreter/tests/fixtures/optional_chaining/nested_field_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/nested_field_chain.subm rename to crates/interpreter/tests/fixtures/optional_chaining/nested_field_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/non_null_division.ts b/crates/interpreter/tests/fixtures/optional_chaining/non_null_division.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/non_null_division.ts rename to crates/interpreter/tests/fixtures/optional_chaining/non_null_division.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/non_null_void_result.ts b/crates/interpreter/tests/fixtures/optional_chaining/non_null_void_result.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/non_null_void_result.ts rename to crates/interpreter/tests/fixtures/optional_chaining/non_null_void_result.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call.subm b/crates/interpreter/tests/fixtures/optional_chaining/optional_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_call.subm rename to crates/interpreter/tests/fixtures/optional_chaining/optional_call.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_call_defaults_and_rest.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_nullable_return.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_call_nullable_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_call_nullable_return.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_call_nullable_return.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_accessor.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_class_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_accessor.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_class_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_class_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_class_field.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field_chain.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_class_field_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_class_field_chain.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_class_field_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_generic_method.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_generic_method.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_generic_method.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_generic_method.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_index.subm b/crates/interpreter/tests/fixtures/optional_chaining/optional_index.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_index.subm rename to crates/interpreter/tests/fixtures/optional_chaining/optional_index.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_index_bounds.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_index_bounds.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_index_bounds.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_index_bounds.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_inherited_field.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_inherited_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_inherited_field.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_inherited_field.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_accessor.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_interface_accessor.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_accessor.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_interface_accessor.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_property.subm b/crates/interpreter/tests/fixtures/optional_chaining/optional_interface_property.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_interface_property.subm rename to crates/interpreter/tests/fixtures/optional_chaining/optional_interface_property.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_method.subm b/crates/interpreter/tests/fixtures/optional_chaining/optional_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_method.subm rename to crates/interpreter/tests/fixtures/optional_chaining/optional_method.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_method_nullable_return.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_method_nullable_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_method_nullable_return.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_method_nullable_return.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_narrowed_step.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_narrowed_step.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_narrowed_step.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_narrowed_step.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_non_null_continuation.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_non_null_continuation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_non_null_continuation.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_non_null_continuation.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_object_prelude_member.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_object_prelude_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_object_prelude_member.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_object_prelude_member.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_primitive_receiver.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_primitive_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_primitive_receiver.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_primitive_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_redundant_primitive.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_redundant_primitive.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_redundant_primitive.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_redundant_primitive.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_union_field.ts b/crates/interpreter/tests/fixtures/optional_chaining/optional_union_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_union_field.ts rename to crates/interpreter/tests/fixtures/optional_chaining/optional_union_field.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/optional_void_method.subm b/crates/interpreter/tests/fixtures/optional_chaining/optional_void_method.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/optional_void_method.subm rename to crates/interpreter/tests/fixtures/optional_chaining/optional_void_method.subm diff --git a/crates/submilli-engine/tests/fixtures/optional_chaining/void_result_bindings.ts b/crates/interpreter/tests/fixtures/optional_chaining/void_result_bindings.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_chaining/void_result_bindings.ts rename to crates/interpreter/tests/fixtures/optional_chaining/void_result_bindings.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_field_written_null_serializes.ts b/crates/interpreter/tests/fixtures/optional_field_written_null_serializes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_field_written_null_serializes.ts rename to crates/interpreter/tests/fixtures/optional_field_written_null_serializes.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_to_json_property.ts b/crates/interpreter/tests/fixtures/optional_to_json_property.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_to_json_property.ts rename to crates/interpreter/tests/fixtures/optional_to_json_property.ts diff --git a/crates/submilli-engine/tests/fixtures/optional_to_string_property.ts b/crates/interpreter/tests/fixtures/optional_to_string_property.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/optional_to_string_property.ts rename to crates/interpreter/tests/fixtures/optional_to_string_property.ts diff --git a/crates/submilli-engine/tests/fixtures/override_narrows_return_with_finally.ts b/crates/interpreter/tests/fixtures/override_narrows_return_with_finally.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_narrows_return_with_finally.ts rename to crates/interpreter/tests/fixtures/override_narrows_return_with_finally.ts diff --git a/crates/submilli-engine/tests/fixtures/override_returns_into_narrower_slot.ts b/crates/interpreter/tests/fixtures/override_returns_into_narrower_slot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_returns_into_narrower_slot.ts rename to crates/interpreter/tests/fixtures/override_returns_into_narrower_slot.ts diff --git a/crates/submilli-engine/tests/fixtures/override_slot_variance.ts b/crates/interpreter/tests/fixtures/override_slot_variance.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_slot_variance.ts rename to crates/interpreter/tests/fixtures/override_slot_variance.ts diff --git a/crates/submilli-engine/tests/fixtures/override_variance_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/override_variance_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_variance_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/override_variance_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/override_variance_cross_package/base/lib.ts b/crates/interpreter/tests/fixtures/override_variance_cross_package/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_variance_cross_package/base/lib.ts rename to crates/interpreter/tests/fixtures/override_variance_cross_package/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/override_variance_cross_package/child/lib.ts b/crates/interpreter/tests/fixtures/override_variance_cross_package/child/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_variance_cross_package/child/lib.ts rename to crates/interpreter/tests/fixtures/override_variance_cross_package/child/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/override_variance_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/override_variance_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/override_variance_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/override_variance_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_key/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_binding_key/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_binding_key/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_binding_key/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts b/crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_binding_paths_resolve/types.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_dynamic_name/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_dynamic_name/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_dynamic_name/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_dynamic_name/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_extra_tag/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_extra_tag/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_extra_tag/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_extra_tag/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_missing_tag/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_missing_tag/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_missing_tag/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_missing_tag/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_nonliteral_payload/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_payload_key/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_payload_key/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_payload_key/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_payload_key/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/types.ts b/crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_field/types.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_unknown_field/types.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts b/crates/interpreter/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/capability_unknown_parameter/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/class_member_bodies/lib.ts b/crates/interpreter/tests/fixtures/package_rules/class_member_bodies/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/class_member_bodies/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/class_member_bodies/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/class_missing_return/lib.ts b/crates/interpreter/tests/fixtures/package_rules/class_missing_return/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/class_missing_return/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/class_missing_return/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts b/crates/interpreter/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/class_switch_fallthrough/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/class_unreachable_code/lib.ts b/crates/interpreter/tests/fixtures/package_rules/class_unreachable_code/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/class_unreachable_code/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/class_unreachable_code/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/doc_callable_members/lib.ts b/crates/interpreter/tests/fixtures/package_rules/doc_callable_members/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/doc_callable_members/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/doc_callable_members/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/doc_consistency/lib.ts b/crates/interpreter/tests/fixtures/package_rules/doc_consistency/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/doc_consistency/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/doc_consistency/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts b/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts b/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/consumer/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts b/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/levels/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest b/crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest rename to crates/interpreter/tests/fixtures/package_rules/enum_dependency_exhaustive/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts b/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/levels.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts b/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts b/crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts rename to crates/interpreter/tests/fixtures/package_rules/enum_other_module_exhaustive/shades.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/missing_return/lib.ts b/crates/interpreter/tests/fixtures/package_rules/missing_return/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/missing_return/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/missing_return/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/switch_fallthrough/lib.ts b/crates/interpreter/tests/fixtures/package_rules/switch_fallthrough/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/switch_fallthrough/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/switch_fallthrough/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/top_level_return/lib.ts b/crates/interpreter/tests/fixtures/package_rules/top_level_return/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/top_level_return/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/top_level_return/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/unassigned_class_field/lib.ts b/crates/interpreter/tests/fixtures/package_rules/unassigned_class_field/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/unassigned_class_field/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/unassigned_class_field/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/package_rules/unreachable_code/lib.ts b/crates/interpreter/tests/fixtures/package_rules/unreachable_code/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/package_rules/unreachable_code/lib.ts rename to crates/interpreter/tests/fixtures/package_rules/unreachable_code/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/packages/class_member_object_literal_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/packages/closure_param_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/host/lib.ts b/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/host/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/host/lib.ts rename to crates/interpreter/tests/fixtures/packages/closure_param_cross_package/host/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/packages/closure_param_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_param_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/packages/closure_param_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts b/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts rename to crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts b/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts rename to crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/base/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest b/crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest rename to crates/interpreter/tests/fixtures/packages/closure_sig_inherited_from_dependency/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/packages/const_ref_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts b/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts rename to crates/interpreter/tests/fixtures/packages/const_ref_cross_package/cfg/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/packages/const_ref_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/const_ref_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/packages/const_ref_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts b/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts rename to crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts b/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest b/crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest rename to crates/interpreter/tests/fixtures/packages/interface_dispatch_in_declaring_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/packages/recursive_alias_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts b/crates/interpreter/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts rename to crates/interpreter/tests/fixtures/parameter_defaults_reference_earlier_parameters.ts diff --git a/crates/submilli-engine/tests/fixtures/parameter_literal_union_default_write.ts b/crates/interpreter/tests/fixtures/parameter_literal_union_default_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/parameter_literal_union_default_write.ts rename to crates/interpreter/tests/fixtures/parameter_literal_union_default_write.ts diff --git a/crates/submilli-engine/tests/fixtures/parse_int_radix_undefined.ts b/crates/interpreter/tests/fixtures/parse_int_radix_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/parse_int_radix_undefined.ts rename to crates/interpreter/tests/fixtures/parse_int_radix_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_basic.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_basic.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_bigint.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_bigint.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_bigint.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_bigint.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_captured.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_captured.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_captured.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_captured.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_field.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_field.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_field.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_for_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_global.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_global.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_global.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_global.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_in_expression.subm diff --git a/crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_index.subm b/crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_index.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/postfix_incdec/inc_dec_index.subm rename to crates/interpreter/tests/fixtures/postfix_incdec/inc_dec_index.subm diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_in_nullable.ts b/crates/interpreter/tests/fixtures/property_regressions/expect_error_in_nullable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/expect_error_in_nullable.ts rename to crates/interpreter/tests/fixtures/property_regressions/expect_error_in_nullable.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts b/crates/interpreter/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts rename to crates/interpreter/tests/fixtures/property_regressions/expect_error_inherited_write_only.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_optional_write_only.ts b/crates/interpreter/tests/fixtures/property_regressions/expect_error_optional_write_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/expect_error_optional_write_only.ts rename to crates/interpreter/tests/fixtures/property_regressions/expect_error_optional_write_only.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts b/crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts rename to crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_assignment.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_implements.ts b/crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_implements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/expect_error_write_only_implements.ts rename to crates/interpreter/tests/fixtures/property_regressions/expect_error_write_only_implements.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/in_accessors.ts b/crates/interpreter/tests/fixtures/property_regressions/in_accessors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/in_accessors.ts rename to crates/interpreter/tests/fixtures/property_regressions/in_accessors.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/in_erased_presence.ts b/crates/interpreter/tests/fixtures/property_regressions/in_erased_presence.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/in_erased_presence.ts rename to crates/interpreter/tests/fixtures/property_regressions/in_erased_presence.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/in_presence.ts b/crates/interpreter/tests/fixtures/property_regressions/in_presence.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/in_presence.ts rename to crates/interpreter/tests/fixtures/property_regressions/in_presence.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/inherited_accessors.ts b/crates/interpreter/tests/fixtures/property_regressions/inherited_accessors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/inherited_accessors.ts rename to crates/interpreter/tests/fixtures/property_regressions/inherited_accessors.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/interface_json_surrogates.ts b/crates/interpreter/tests/fixtures/property_regressions/interface_json_surrogates.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/interface_json_surrogates.ts rename to crates/interpreter/tests/fixtures/property_regressions/interface_json_surrogates.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/interface_postfix.ts b/crates/interpreter/tests/fixtures/property_regressions/interface_postfix.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/interface_postfix.ts rename to crates/interpreter/tests/fixtures/property_regressions/interface_postfix.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/interface_wide_mutation.ts b/crates/interpreter/tests/fixtures/property_regressions/interface_wide_mutation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/interface_wide_mutation.ts rename to crates/interpreter/tests/fixtures/property_regressions/interface_wide_mutation.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/app/main.ts b/crates/interpreter/tests/fixtures/property_regressions/postfix_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/app/main.ts rename to crates/interpreter/tests/fixtures/property_regressions/postfix_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/lib/lib.ts b/crates/interpreter/tests/fixtures/property_regressions/postfix_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/property_regressions/postfix_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/packages.manifest b/crates/interpreter/tests/fixtures/property_regressions/postfix_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/postfix_package/packages.manifest rename to crates/interpreter/tests/fixtures/property_regressions/postfix_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/recursive_mutation.ts b/crates/interpreter/tests/fixtures/property_regressions/recursive_mutation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/recursive_mutation.ts rename to crates/interpreter/tests/fixtures/property_regressions/recursive_mutation.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/required_undefined_round_trip.ts b/crates/interpreter/tests/fixtures/property_regressions/required_undefined_round_trip.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/required_undefined_round_trip.ts rename to crates/interpreter/tests/fixtures/property_regressions/required_undefined_round_trip.ts diff --git a/crates/submilli-engine/tests/fixtures/property_regressions/required_unknown.ts b/crates/interpreter/tests/fixtures/property_regressions/required_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/property_regressions/required_unknown.ts rename to crates/interpreter/tests/fixtures/property_regressions/required_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/radix_number_literals.subm b/crates/interpreter/tests/fixtures/radix_number_literals.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/radix_number_literals.subm rename to crates/interpreter/tests/fixtures/radix_number_literals.subm diff --git a/crates/submilli-engine/tests/fixtures/readonly/assignment_narrows_to_value_type.ts b/crates/interpreter/tests/fixtures/readonly/assignment_narrows_to_value_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/assignment_narrows_to_value_type.ts rename to crates/interpreter/tests/fixtures/readonly/assignment_narrows_to_value_type.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_array_writes.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_array_writes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_array_writes.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_array_writes.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_field_shown_in_object_type.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_non_array.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_non_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_non_array.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_non_array.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_survives_value_shape.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts b/crates/interpreter/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts rename to crates/interpreter/tests/fixtures/readonly/expect_error_readonly_to_mutable.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/getonly_cannot_implement_writable.ts b/crates/interpreter/tests/fixtures/readonly/getonly_cannot_implement_writable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/getonly_cannot_implement_writable.ts rename to crates/interpreter/tests/fixtures/readonly/getonly_cannot_implement_writable.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/inline_object_runtime.ts b/crates/interpreter/tests/fixtures/readonly/inline_object_runtime.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/inline_object_runtime.ts rename to crates/interpreter/tests/fixtures/readonly/inline_object_runtime.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/interface_property_write_rejected.ts b/crates/interpreter/tests/fixtures/readonly/interface_property_write_rejected.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/interface_property_write_rejected.ts rename to crates/interpreter/tests/fixtures/readonly/interface_property_write_rejected.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/object_type_property_write_rejected.ts b/crates/interpreter/tests/fixtures/readonly/object_type_property_write_rejected.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/object_type_property_write_rejected.ts rename to crates/interpreter/tests/fixtures/readonly/object_type_property_write_rejected.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/readonly_array_reads.ts b/crates/interpreter/tests/fixtures/readonly/readonly_array_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/readonly_array_reads.ts rename to crates/interpreter/tests/fixtures/readonly/readonly_array_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly/writable_property_write_ok.ts b/crates/interpreter/tests/fixtures/readonly/writable_property_write_ok.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly/writable_property_write_ok.ts rename to crates/interpreter/tests/fixtures/readonly/writable_property_write_ok.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly_cast_qualifiers.ts b/crates/interpreter/tests/fixtures/readonly_cast_qualifiers.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly_cast_qualifiers.ts rename to crates/interpreter/tests/fixtures/readonly_cast_qualifiers.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly_rest_parameter.ts b/crates/interpreter/tests/fixtures/readonly_rest_parameter.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly_rest_parameter.ts rename to crates/interpreter/tests/fixtures/readonly_rest_parameter.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly_rest_parameter_write.ts b/crates/interpreter/tests/fixtures/readonly_rest_parameter_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly_rest_parameter_write.ts rename to crates/interpreter/tests/fixtures/readonly_rest_parameter_write.ts diff --git a/crates/submilli-engine/tests/fixtures/readonly_string_length.subm b/crates/interpreter/tests/fixtures/readonly_string_length.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/readonly_string_length.subm rename to crates/interpreter/tests/fixtures/readonly_string_length.subm diff --git a/crates/submilli-engine/tests/fixtures/records/cross_package/app/main.ts b/crates/interpreter/tests/fixtures/records/cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/records/cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/records/cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/records/cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/records/cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/records/cross_package/packages.manifest b/crates/interpreter/tests/fixtures/records/cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/records/cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/records/indexed_growth_and_equality.ts b/crates/interpreter/tests/fixtures/records/indexed_growth_and_equality.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/indexed_growth_and_equality.ts rename to crates/interpreter/tests/fixtures/records/indexed_growth_and_equality.ts diff --git a/crates/submilli-engine/tests/fixtures/records/optional_dynamic_presence.ts b/crates/interpreter/tests/fixtures/records/optional_dynamic_presence.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/optional_dynamic_presence.ts rename to crates/interpreter/tests/fixtures/records/optional_dynamic_presence.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_accessors.ts b/crates/interpreter/tests/fixtures/records/record_accessors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_accessors.ts rename to crates/interpreter/tests/fixtures/records/record_accessors.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_bad_computed_spread.ts b/crates/interpreter/tests/fixtures/records/record_bad_computed_spread.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_bad_computed_spread.ts rename to crates/interpreter/tests/fixtures/records/record_bad_computed_spread.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_basic.ts b/crates/interpreter/tests/fixtures/records/record_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_basic.ts rename to crates/interpreter/tests/fixtures/records/record_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_checked_reads.ts b/crates/interpreter/tests/fixtures/records/record_checked_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_checked_reads.ts rename to crates/interpreter/tests/fixtures/records/record_checked_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_class_guards.ts b/crates/interpreter/tests/fixtures/records/record_class_guards.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_class_guards.ts rename to crates/interpreter/tests/fixtures/records/record_class_guards.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_conditional_spread.ts b/crates/interpreter/tests/fixtures/records/record_conditional_spread.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_conditional_spread.ts rename to crates/interpreter/tests/fixtures/records/record_conditional_spread.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_errors.ts b/crates/interpreter/tests/fixtures/records/record_errors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_errors.ts rename to crates/interpreter/tests/fixtures/records/record_errors.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_evaluation.ts b/crates/interpreter/tests/fixtures/records/record_evaluation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_evaluation.ts rename to crates/interpreter/tests/fixtures/records/record_evaluation.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_features.ts b/crates/interpreter/tests/fixtures/records/record_features.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_features.ts rename to crates/interpreter/tests/fixtures/records/record_features.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_forward_index.ts b/crates/interpreter/tests/fixtures/records/record_forward_index.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_forward_index.ts rename to crates/interpreter/tests/fixtures/records/record_forward_index.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_function_receiver.ts b/crates/interpreter/tests/fixtures/records/record_function_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_function_receiver.ts rename to crates/interpreter/tests/fixtures/records/record_function_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_generic_contract_errors.ts b/crates/interpreter/tests/fixtures/records/record_generic_contract_errors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_generic_contract_errors.ts rename to crates/interpreter/tests/fixtures/records/record_generic_contract_errors.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_generic_method_errors.ts b/crates/interpreter/tests/fixtures/records/record_generic_method_errors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_generic_method_errors.ts rename to crates/interpreter/tests/fixtures/records/record_generic_method_errors.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_generic_methods.ts b/crates/interpreter/tests/fixtures/records/record_generic_methods.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_generic_methods.ts rename to crates/interpreter/tests/fixtures/records/record_generic_methods.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_composition.ts b/crates/interpreter/tests/fixtures/records/record_inherit_composition.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_composition.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_composition.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_composition_errors.ts b/crates/interpreter/tests/fixtures/records/record_inherit_composition_errors.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_composition_errors.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_composition_errors.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_conflicts.ts b/crates/interpreter/tests/fixtures/records/record_inherit_conflicts.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_conflicts.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_conflicts.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_forward_alias.ts b/crates/interpreter/tests/fixtures/records/record_inherit_forward_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_forward_alias.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_forward_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_members.ts b/crates/interpreter/tests/fixtures/records/record_inherit_members.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_members.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_members.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_inherit_narrow.ts b/crates/interpreter/tests/fixtures/records/record_inherit_narrow.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_inherit_narrow.ts rename to crates/interpreter/tests/fixtures/records/record_inherit_narrow.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_interface_reads.ts b/crates/interpreter/tests/fixtures/records/record_interface_reads.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_interface_reads.ts rename to crates/interpreter/tests/fixtures/records/record_interface_reads.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_literal_writes.ts b/crates/interpreter/tests/fixtures/records/record_literal_writes.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_literal_writes.ts rename to crates/interpreter/tests/fixtures/records/record_literal_writes.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_postfix_checked.ts b/crates/interpreter/tests/fixtures/records/record_postfix_checked.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_postfix_checked.ts rename to crates/interpreter/tests/fixtures/records/record_postfix_checked.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_recursive.ts b/crates/interpreter/tests/fixtures/records/record_recursive.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_recursive.ts rename to crates/interpreter/tests/fixtures/records/record_recursive.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_recursive_interface_error.ts b/crates/interpreter/tests/fixtures/records/record_recursive_interface_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_recursive_interface_error.ts rename to crates/interpreter/tests/fixtures/records/record_recursive_interface_error.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_structural_write.ts b/crates/interpreter/tests/fixtures/records/record_structural_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_structural_write.ts rename to crates/interpreter/tests/fixtures/records/record_structural_write.ts diff --git a/crates/submilli-engine/tests/fixtures/records/record_unions.ts b/crates/interpreter/tests/fixtures/records/record_unions.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/records/record_unions.ts rename to crates/interpreter/tests/fixtures/records/record_unions.ts diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_linked_list.subm b/crates/interpreter/tests/fixtures/recursive-types/alias_linked_list.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_linked_list.subm rename to crates/interpreter/tests/fixtures/recursive-types/alias_linked_list.subm diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts b/crates/interpreter/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts rename to crates/interpreter/tests/fixtures/recursive-types/alias_polymorphic_recursion.ts diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_through_array.ts b/crates/interpreter/tests/fixtures/recursive-types/alias_through_array.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_through_array.ts rename to crates/interpreter/tests/fixtures/recursive-types/alias_through_array.ts diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_through_generic_call.ts b/crates/interpreter/tests/fixtures/recursive-types/alias_through_generic_call.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_through_generic_call.ts rename to crates/interpreter/tests/fixtures/recursive-types/alias_through_generic_call.ts diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_tree.subm b/crates/interpreter/tests/fixtures/recursive-types/alias_tree.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_tree.subm rename to crates/interpreter/tests/fixtures/recursive-types/alias_tree.subm diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/alias_union_json.subm b/crates/interpreter/tests/fixtures/recursive-types/alias_union_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/alias_union_json.subm rename to crates/interpreter/tests/fixtures/recursive-types/alias_union_json.subm diff --git a/crates/submilli-engine/tests/fixtures/recursive-types/interface_resolution.subm b/crates/interpreter/tests/fixtures/recursive-types/interface_resolution.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/recursive-types/interface_resolution.subm rename to crates/interpreter/tests/fixtures/recursive-types/interface_resolution.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_exec_basic.subm b/crates/interpreter/tests/fixtures/regex_exec_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_exec_basic.subm rename to crates/interpreter/tests/fixtures/regex_exec_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_flags_all.subm b/crates/interpreter/tests/fixtures/regex_flags_all.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_flags_all.subm rename to crates/interpreter/tests/fixtures/regex_flags_all.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_input_cache.ts b/crates/interpreter/tests/fixtures/regex_input_cache.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_input_cache.ts rename to crates/interpreter/tests/fixtures/regex_input_cache.ts diff --git a/crates/submilli-engine/tests/fixtures/regex_lastindex_non_global.subm b/crates/interpreter/tests/fixtures/regex_lastindex_non_global.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_lastindex_non_global.subm rename to crates/interpreter/tests/fixtures/regex_lastindex_non_global.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_lastindex_sticky.subm b/crates/interpreter/tests/fixtures/regex_lastindex_sticky.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_lastindex_sticky.subm rename to crates/interpreter/tests/fixtures/regex_lastindex_sticky.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_literal_basic.subm b/crates/interpreter/tests/fixtures/regex_literal_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_literal_basic.subm rename to crates/interpreter/tests/fixtures/regex_literal_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_named_captures.subm b/crates/interpreter/tests/fixtures/regex_named_captures.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_named_captures.subm rename to crates/interpreter/tests/fixtures/regex_named_captures.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_named_captures_unmatched.ts b/crates/interpreter/tests/fixtures/regex_named_captures_unmatched.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_named_captures_unmatched.ts rename to crates/interpreter/tests/fixtures/regex_named_captures_unmatched.ts diff --git a/crates/submilli-engine/tests/fixtures/regex_non_ascii_literal.ts b/crates/interpreter/tests/fixtures/regex_non_ascii_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_non_ascii_literal.ts rename to crates/interpreter/tests/fixtures/regex_non_ascii_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/regex_numbered_captures.subm b/crates/interpreter/tests/fixtures/regex_numbered_captures.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_numbered_captures.subm rename to crates/interpreter/tests/fixtures/regex_numbered_captures.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_per_site_lastindex.subm b/crates/interpreter/tests/fixtures/regex_per_site_lastindex.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_per_site_lastindex.subm rename to crates/interpreter/tests/fixtures/regex_per_site_lastindex.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_property_reads.subm b/crates/interpreter/tests/fixtures/regex_property_reads.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_property_reads.subm rename to crates/interpreter/tests/fixtures/regex_property_reads.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_shared_input.ts b/crates/interpreter/tests/fixtures/regex_shared_input.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_shared_input.ts rename to crates/interpreter/tests/fixtures/regex_shared_input.ts diff --git a/crates/submilli-engine/tests/fixtures/regex_test_basic.subm b/crates/interpreter/tests/fixtures/regex_test_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_test_basic.subm rename to crates/interpreter/tests/fixtures/regex_test_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_test_lastindex_global.subm b/crates/interpreter/tests/fixtures/regex_test_lastindex_global.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_test_lastindex_global.subm rename to crates/interpreter/tests/fixtures/regex_test_lastindex_global.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_to_string.subm b/crates/interpreter/tests/fixtures/regex_to_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_to_string.subm rename to crates/interpreter/tests/fixtures/regex_to_string.subm diff --git a/crates/submilli-engine/tests/fixtures/regex_utf16_offsets.ts b/crates/interpreter/tests/fixtures/regex_utf16_offsets.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regex_utf16_offsets.ts rename to crates/interpreter/tests/fixtures/regex_utf16_offsets.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_invalid_flags_type.ts b/crates/interpreter/tests/fixtures/regexp_invalid_flags_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_invalid_flags_type.ts rename to crates/interpreter/tests/fixtures/regexp_invalid_flags_type.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_match_keeps_lone_surrogates.subm b/crates/interpreter/tests/fixtures/regexp_match_keeps_lone_surrogates.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_match_keeps_lone_surrogates.subm rename to crates/interpreter/tests/fixtures/regexp_match_keeps_lone_surrogates.subm diff --git a/crates/submilli-engine/tests/fixtures/regexp_missing_source.ts b/crates/interpreter/tests/fixtures/regexp_missing_source.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_missing_source.ts rename to crates/interpreter/tests/fixtures/regexp_missing_source.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_optional_flags.ts b/crates/interpreter/tests/fixtures/regexp_optional_flags.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_optional_flags.ts rename to crates/interpreter/tests/fixtures/regexp_optional_flags.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_replace_split_match_js.ts b/crates/interpreter/tests/fixtures/regexp_replace_split_match_js.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_replace_split_match_js.ts rename to crates/interpreter/tests/fixtures/regexp_replace_split_match_js.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_shorthand_classes_match_js.ts b/crates/interpreter/tests/fixtures/regexp_shorthand_classes_match_js.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_shorthand_classes_match_js.ts rename to crates/interpreter/tests/fixtures/regexp_shorthand_classes_match_js.ts diff --git a/crates/submilli-engine/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts b/crates/interpreter/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts rename to crates/interpreter/tests/fixtures/regexp_split_unmatched_capture_is_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/rejected_field_write_rhs_hint.ts b/crates/interpreter/tests/fixtures/rejected_field_write_rhs_hint.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/rejected_field_write_rhs_hint.ts rename to crates/interpreter/tests/fixtures/rejected_field_write_rhs_hint.ts diff --git a/crates/submilli-engine/tests/fixtures/rest_callback_for_fixed_arity.ts b/crates/interpreter/tests/fixtures/rest_callback_for_fixed_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/rest_callback_for_fixed_arity.ts rename to crates/interpreter/tests/fixtures/rest_callback_for_fixed_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/rest_param_arrow.subm b/crates/interpreter/tests/fixtures/rest_param_arrow.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/rest_param_arrow.subm rename to crates/interpreter/tests/fixtures/rest_param_arrow.subm diff --git a/crates/submilli-engine/tests/fixtures/rest_param_basic.subm b/crates/interpreter/tests/fixtures/rest_param_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/rest_param_basic.subm rename to crates/interpreter/tests/fixtures/rest_param_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/rest_param_generic.subm b/crates/interpreter/tests/fixtures/rest_param_generic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/rest_param_generic.subm rename to crates/interpreter/tests/fixtures/rest_param_generic.subm diff --git a/crates/submilli-engine/tests/fixtures/rest_param_mixed.subm b/crates/interpreter/tests/fixtures/rest_param_mixed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/rest_param_mixed.subm rename to crates/interpreter/tests/fixtures/rest_param_mixed.subm diff --git a/crates/submilli-engine/tests/fixtures/return_paths_void_union_and_getters.ts b/crates/interpreter/tests/fixtures/return_paths_void_union_and_getters.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/return_paths_void_union_and_getters.ts rename to crates/interpreter/tests/fixtures/return_paths_void_union_and_getters.ts diff --git a/crates/submilli-engine/tests/fixtures/secrets_main_denied.ts b/crates/interpreter/tests/fixtures/secrets_main_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/secrets_main_denied.ts rename to crates/interpreter/tests/fixtures/secrets_main_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/session_basic.ts b/crates/interpreter/tests/fixtures/session_basic.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_basic.ts rename to crates/interpreter/tests/fixtures/session_basic.ts diff --git a/crates/submilli-engine/tests/fixtures/session_cursor_length_budget.ts b/crates/interpreter/tests/fixtures/session_cursor_length_budget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_cursor_length_budget.ts rename to crates/interpreter/tests/fixtures/session_cursor_length_budget.ts diff --git a/crates/submilli-engine/tests/fixtures/session_denied.ts b/crates/interpreter/tests/fixtures/session_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_denied.ts rename to crates/interpreter/tests/fixtures/session_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/session_get_erased.ts b/crates/interpreter/tests/fixtures/session_get_erased.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_get_erased.ts rename to crates/interpreter/tests/fixtures/session_get_erased.ts diff --git a/crates/submilli-engine/tests/fixtures/session_get_mismatch.ts b/crates/interpreter/tests/fixtures/session_get_mismatch.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_get_mismatch.ts rename to crates/interpreter/tests/fixtures/session_get_mismatch.ts diff --git a/crates/submilli-engine/tests/fixtures/session_get_unknown.ts b/crates/interpreter/tests/fixtures/session_get_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_get_unknown.ts rename to crates/interpreter/tests/fixtures/session_get_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/session_list.ts b/crates/interpreter/tests/fixtures/session_list.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_list.ts rename to crates/interpreter/tests/fixtures/session_list.ts diff --git a/crates/submilli-engine/tests/fixtures/session_list_cursor_is_sealed.ts b/crates/interpreter/tests/fixtures/session_list_cursor_is_sealed.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_list_cursor_is_sealed.ts rename to crates/interpreter/tests/fixtures/session_list_cursor_is_sealed.ts diff --git a/crates/submilli-engine/tests/fixtures/session_list_filtered.ts b/crates/interpreter/tests/fixtures/session_list_filtered.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_list_filtered.ts rename to crates/interpreter/tests/fixtures/session_list_filtered.ts diff --git a/crates/submilli-engine/tests/fixtures/session_remove_denied.ts b/crates/interpreter/tests/fixtures/session_remove_denied.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_remove_denied.ts rename to crates/interpreter/tests/fixtures/session_remove_denied.ts diff --git a/crates/submilli-engine/tests/fixtures/session_surrogate_fidelity.ts b/crates/interpreter/tests/fixtures/session_surrogate_fidelity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_surrogate_fidelity.ts rename to crates/interpreter/tests/fixtures/session_surrogate_fidelity.ts diff --git a/crates/submilli-engine/tests/fixtures/session_typed_get.ts b/crates/interpreter/tests/fixtures/session_typed_get.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_typed_get.ts rename to crates/interpreter/tests/fixtures/session_typed_get.ts diff --git a/crates/submilli-engine/tests/fixtures/session_unsupported_value.ts b/crates/interpreter/tests/fixtures/session_unsupported_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/session_unsupported_value.ts rename to crates/interpreter/tests/fixtures/session_unsupported_value.ts diff --git a/crates/submilli-engine/tests/fixtures/set_algebra.subm b/crates/interpreter/tests/fixtures/set_algebra.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/set_algebra.subm rename to crates/interpreter/tests/fixtures/set_algebra.subm diff --git a/crates/submilli-engine/tests/fixtures/set_iteration_parity.subm b/crates/interpreter/tests/fixtures/set_iteration_parity.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/set_iteration_parity.subm rename to crates/interpreter/tests/fixtures/set_iteration_parity.subm diff --git a/crates/submilli-engine/tests/fixtures/set_relations.subm b/crates/interpreter/tests/fixtures/set_relations.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/set_relations.subm rename to crates/interpreter/tests/fixtures/set_relations.subm diff --git a/crates/submilli-engine/tests/fixtures/shared_serializer_buffer.ts b/crates/interpreter/tests/fixtures/shared_serializer_buffer.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/shared_serializer_buffer.ts rename to crates/interpreter/tests/fixtures/shared_serializer_buffer.ts diff --git a/crates/submilli-engine/tests/fixtures/spread/array_basic.subm b/crates/interpreter/tests/fixtures/spread/array_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/array_basic.subm rename to crates/interpreter/tests/fixtures/spread/array_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/array_empty_source.subm b/crates/interpreter/tests/fixtures/spread/array_empty_source.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/array_empty_source.subm rename to crates/interpreter/tests/fixtures/spread/array_empty_source.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/array_only_spreads.subm b/crates/interpreter/tests/fixtures/spread/array_only_spreads.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/array_only_spreads.subm rename to crates/interpreter/tests/fixtures/spread/array_only_spreads.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/err_array_spread_element_mismatch.subm b/crates/interpreter/tests/fixtures/spread/err_array_spread_element_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/err_array_spread_element_mismatch.subm rename to crates/interpreter/tests/fixtures/spread/err_array_spread_element_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/err_array_spread_non_array.subm b/crates/interpreter/tests/fixtures/spread/err_array_spread_non_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/err_array_spread_non_array.subm rename to crates/interpreter/tests/fixtures/spread/err_array_spread_non_array.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/err_object_spread_interface.subm b/crates/interpreter/tests/fixtures/spread/err_object_spread_interface.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/err_object_spread_interface.subm rename to crates/interpreter/tests/fixtures/spread/err_object_spread_interface.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/err_object_spread_non_object.subm b/crates/interpreter/tests/fixtures/spread/err_object_spread_non_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/err_object_spread_non_object.subm rename to crates/interpreter/tests/fixtures/spread/err_object_spread_non_object.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/object_basic.subm b/crates/interpreter/tests/fixtures/spread/object_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/object_basic.subm rename to crates/interpreter/tests/fixtures/spread/object_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/object_multiple_spreads.subm b/crates/interpreter/tests/fixtures/spread/object_multiple_spreads.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/object_multiple_spreads.subm rename to crates/interpreter/tests/fixtures/spread/object_multiple_spreads.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/object_override_literal_after.subm b/crates/interpreter/tests/fixtures/spread/object_override_literal_after.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/object_override_literal_after.subm rename to crates/interpreter/tests/fixtures/spread/object_override_literal_after.subm diff --git a/crates/submilli-engine/tests/fixtures/spread/object_override_literal_before.subm b/crates/interpreter/tests/fixtures/spread/object_override_literal_before.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread/object_override_literal_before.subm rename to crates/interpreter/tests/fixtures/spread/object_override_literal_before.subm diff --git a/crates/submilli-engine/tests/fixtures/spread_index_signature_union.ts b/crates/interpreter/tests/fixtures/spread_index_signature_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread_index_signature_union.ts rename to crates/interpreter/tests/fixtures/spread_index_signature_union.ts diff --git a/crates/submilli-engine/tests/fixtures/spread_into_discriminated_union.ts b/crates/interpreter/tests/fixtures/spread_into_discriminated_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread_into_discriminated_union.ts rename to crates/interpreter/tests/fixtures/spread_into_discriminated_union.ts diff --git a/crates/submilli-engine/tests/fixtures/spread_of_conditional_or_union.ts b/crates/interpreter/tests/fixtures/spread_of_conditional_or_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread_of_conditional_or_union.ts rename to crates/interpreter/tests/fixtures/spread_of_conditional_or_union.ts diff --git a/crates/submilli-engine/tests/fixtures/spread_of_falsy_value.ts b/crates/interpreter/tests/fixtures/spread_of_falsy_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread_of_falsy_value.ts rename to crates/interpreter/tests/fixtures/spread_of_falsy_value.ts diff --git a/crates/submilli-engine/tests/fixtures/spread_union_assigned_back.ts b/crates/interpreter/tests/fixtures/spread_union_assigned_back.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/spread_union_assigned_back.ts rename to crates/interpreter/tests/fixtures/spread_union_assigned_back.ts diff --git a/crates/submilli-engine/tests/fixtures/static_binding_as_value.ts b/crates/interpreter/tests/fixtures/static_binding_as_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/static_binding_as_value.ts rename to crates/interpreter/tests/fixtures/static_binding_as_value.ts diff --git a/crates/submilli-engine/tests/fixtures/strict_mode_reserved_words_as_properties.ts b/crates/interpreter/tests/fixtures/strict_mode_reserved_words_as_properties.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/strict_mode_reserved_words_as_properties.ts rename to crates/interpreter/tests/fixtures/strict_mode_reserved_words_as_properties.ts diff --git a/crates/submilli-engine/tests/fixtures/string_admitted_builders.ts b/crates/interpreter/tests/fixtures/string_admitted_builders.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_admitted_builders.ts rename to crates/interpreter/tests/fixtures/string_admitted_builders.ts diff --git a/crates/submilli-engine/tests/fixtures/string_at_nullable.ts b/crates/interpreter/tests/fixtures/string_at_nullable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_at_nullable.ts rename to crates/interpreter/tests/fixtures/string_at_nullable.ts diff --git a/crates/submilli-engine/tests/fixtures/string_case.subm b/crates/interpreter/tests/fixtures/string_case.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_case.subm rename to crates/interpreter/tests/fixtures/string_case.subm diff --git a/crates/submilli-engine/tests/fixtures/string_char_at.subm b/crates/interpreter/tests/fixtures/string_char_at.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_char_at.subm rename to crates/interpreter/tests/fixtures/string_char_at.subm diff --git a/crates/submilli-engine/tests/fixtures/string_code_point_at_out_of_range.ts b/crates/interpreter/tests/fixtures/string_code_point_at_out_of_range.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_code_point_at_out_of_range.ts rename to crates/interpreter/tests/fixtures/string_code_point_at_out_of_range.ts diff --git a/crates/submilli-engine/tests/fixtures/string_concat.subm b/crates/interpreter/tests/fixtures/string_concat.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_concat.subm rename to crates/interpreter/tests/fixtures/string_concat.subm diff --git a/crates/submilli-engine/tests/fixtures/string_for_of.subm b/crates/interpreter/tests/fixtures/string_for_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_for_of.subm rename to crates/interpreter/tests/fixtures/string_for_of.subm diff --git a/crates/submilli-engine/tests/fixtures/string_from_char_code.subm b/crates/interpreter/tests/fixtures/string_from_char_code.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_from_char_code.subm rename to crates/interpreter/tests/fixtures/string_from_char_code.subm diff --git a/crates/submilli-engine/tests/fixtures/string_from_char_code_wraps.ts b/crates/interpreter/tests/fixtures/string_from_char_code_wraps.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_from_char_code_wraps.ts rename to crates/interpreter/tests/fixtures/string_from_char_code_wraps.ts diff --git a/crates/submilli-engine/tests/fixtures/string_from_code_point.subm b/crates/interpreter/tests/fixtures/string_from_code_point.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_from_code_point.subm rename to crates/interpreter/tests/fixtures/string_from_code_point.subm diff --git a/crates/submilli-engine/tests/fixtures/string_index_of.subm b/crates/interpreter/tests/fixtures/string_index_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_index_of.subm rename to crates/interpreter/tests/fixtures/string_index_of.subm diff --git a/crates/submilli-engine/tests/fixtures/string_key_member_access.ts b/crates/interpreter/tests/fixtures/string_key_member_access.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_key_member_access.ts rename to crates/interpreter/tests/fixtures/string_key_member_access.ts diff --git a/crates/submilli-engine/tests/fixtures/string_length.subm b/crates/interpreter/tests/fixtures/string_length.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_length.subm rename to crates/interpreter/tests/fixtures/string_length.subm diff --git a/crates/submilli-engine/tests/fixtures/string_linear_search.ts b/crates/interpreter/tests/fixtures/string_linear_search.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_linear_search.ts rename to crates/interpreter/tests/fixtures/string_linear_search.ts diff --git a/crates/submilli-engine/tests/fixtures/string_literal_lone_surrogates.ts b/crates/interpreter/tests/fixtures/string_literal_lone_surrogates.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_literal_lone_surrogates.ts rename to crates/interpreter/tests/fixtures/string_literal_lone_surrogates.ts diff --git a/crates/submilli-engine/tests/fixtures/string_match_all.subm b/crates/interpreter/tests/fixtures/string_match_all.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_match_all.subm rename to crates/interpreter/tests/fixtures/string_match_all.subm diff --git a/crates/submilli-engine/tests/fixtures/string_match_and_search.subm b/crates/interpreter/tests/fixtures/string_match_and_search.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_match_and_search.subm rename to crates/interpreter/tests/fixtures/string_match_and_search.subm diff --git a/crates/submilli-engine/tests/fixtures/string_multiline_raw_newline.ts b/crates/interpreter/tests/fixtures/string_multiline_raw_newline.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_multiline_raw_newline.ts rename to crates/interpreter/tests/fixtures/string_multiline_raw_newline.ts diff --git a/crates/submilli-engine/tests/fixtures/string_normalize.subm b/crates/interpreter/tests/fixtures/string_normalize.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_normalize.subm rename to crates/interpreter/tests/fixtures/string_normalize.subm diff --git a/crates/submilli-engine/tests/fixtures/string_of_null.ts b/crates/interpreter/tests/fixtures/string_of_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_of_null.ts rename to crates/interpreter/tests/fixtures/string_of_null.ts diff --git a/crates/submilli-engine/tests/fixtures/string_ops_keep_lone_surrogates.ts b/crates/interpreter/tests/fixtures/string_ops_keep_lone_surrogates.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_ops_keep_lone_surrogates.ts rename to crates/interpreter/tests/fixtures/string_ops_keep_lone_surrogates.ts diff --git a/crates/submilli-engine/tests/fixtures/string_or_array_union_methods.ts b/crates/interpreter/tests/fixtures/string_or_array_union_methods.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_or_array_union_methods.ts rename to crates/interpreter/tests/fixtures/string_or_array_union_methods.ts diff --git a/crates/submilli-engine/tests/fixtures/string_ordering.subm b/crates/interpreter/tests/fixtures/string_ordering.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_ordering.subm rename to crates/interpreter/tests/fixtures/string_ordering.subm diff --git a/crates/submilli-engine/tests/fixtures/string_pad.subm b/crates/interpreter/tests/fixtures/string_pad.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_pad.subm rename to crates/interpreter/tests/fixtures/string_pad.subm diff --git a/crates/submilli-engine/tests/fixtures/string_repeat.subm b/crates/interpreter/tests/fixtures/string_repeat.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_repeat.subm rename to crates/interpreter/tests/fixtures/string_repeat.subm diff --git a/crates/submilli-engine/tests/fixtures/string_repeat_negative.subm b/crates/interpreter/tests/fixtures/string_repeat_negative.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_repeat_negative.subm rename to crates/interpreter/tests/fixtures/string_repeat_negative.subm diff --git a/crates/submilli-engine/tests/fixtures/string_replace.subm b/crates/interpreter/tests/fixtures/string_replace.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_replace.subm rename to crates/interpreter/tests/fixtures/string_replace.subm diff --git a/crates/submilli-engine/tests/fixtures/string_replace_all.subm b/crates/interpreter/tests/fixtures/string_replace_all.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_replace_all.subm rename to crates/interpreter/tests/fixtures/string_replace_all.subm diff --git a/crates/submilli-engine/tests/fixtures/string_slice.subm b/crates/interpreter/tests/fixtures/string_slice.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_slice.subm rename to crates/interpreter/tests/fixtures/string_slice.subm diff --git a/crates/submilli-engine/tests/fixtures/string_split.subm b/crates/interpreter/tests/fixtures/string_split.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_split.subm rename to crates/interpreter/tests/fixtures/string_split.subm diff --git a/crates/submilli-engine/tests/fixtures/string_starts_with.subm b/crates/interpreter/tests/fixtures/string_starts_with.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_starts_with.subm rename to crates/interpreter/tests/fixtures/string_starts_with.subm diff --git a/crates/submilli-engine/tests/fixtures/string_trim.subm b/crates/interpreter/tests/fixtures/string_trim.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_trim.subm rename to crates/interpreter/tests/fixtures/string_trim.subm diff --git a/crates/submilli-engine/tests/fixtures/string_well_formed.subm b/crates/interpreter/tests/fixtures/string_well_formed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/string_well_formed.subm rename to crates/interpreter/tests/fixtures/string_well_formed.subm diff --git a/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/structural_equals_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_equals_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/structural_equals_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/structural_equals_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_equals_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/structural_equals_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/structural_equals_cross_package/points/lib.ts b/crates/interpreter/tests/fixtures/structural_equals_cross_package/points/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_equals_cross_package/points/lib.ts rename to crates/interpreter/tests/fixtures/structural_equals_cross_package/points/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/structural_equals_shape_guard.ts b/crates/interpreter/tests/fixtures/structural_equals_shape_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_equals_shape_guard.ts rename to crates/interpreter/tests/fixtures/structural_equals_shape_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/structural_interfaces.subm b/crates/interpreter/tests/fixtures/structural_interfaces.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_interfaces.subm rename to crates/interpreter/tests/fixtures/structural_interfaces.subm diff --git a/crates/submilli-engine/tests/fixtures/structural_visit_budget.ts b/crates/interpreter/tests/fixtures/structural_visit_budget.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/structural_visit_budget.ts rename to crates/interpreter/tests/fixtures/structural_visit_budget.ts diff --git a/crates/submilli-engine/tests/fixtures/subclass_super_on_every_path.ts b/crates/interpreter/tests/fixtures/subclass_super_on_every_path.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/subclass_super_on_every_path.ts rename to crates/interpreter/tests/fixtures/subclass_super_on_every_path.ts diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts b/crates/interpreter/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_arrow_switch_fallthrough.ts diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_assertNever_missing_variant.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_case_type_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_continue_not_in_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_case.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_duplicate_default.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_enum_non_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_fallthrough.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_literal_union_non_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_multi_label_variant_field.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_non_exhaustive_union.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/errors/expect_error_switch_tuple_union_non_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_assertNever_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/switch_assertNever_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_assertNever_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/switch_assertNever_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_break_in_case.subm b/crates/interpreter/tests/fixtures/switch/switch_break_in_case.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_break_in_case.subm rename to crates/interpreter/tests/fixtures/switch/switch_break_in_case.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_break_post_state.subm b/crates/interpreter/tests/fixtures/switch/switch_break_post_state.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_break_post_state.subm rename to crates/interpreter/tests/fixtures/switch/switch_break_post_state.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_default_first.subm b/crates/interpreter/tests/fixtures/switch/switch_default_first.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_default_first.subm rename to crates/interpreter/tests/fixtures/switch/switch_default_first.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_discriminated_union_narrowing.subm b/crates/interpreter/tests/fixtures/switch/switch_discriminated_union_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_discriminated_union_narrowing.subm rename to crates/interpreter/tests/fixtures/switch/switch_discriminated_union_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_enum_discriminant.subm b/crates/interpreter/tests/fixtures/switch/switch_enum_discriminant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_enum_discriminant.subm rename to crates/interpreter/tests/fixtures/switch/switch_enum_discriminant.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm b/crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm rename to crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_no_default.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_string.subm b/crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_enum_exhaustive_string.subm rename to crates/interpreter/tests/fixtures/switch/switch_enum_exhaustive_string.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm b/crates/interpreter/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm rename to crates/interpreter/tests/fixtures/switch/switch_inside_loop_break_targets_switch.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm b/crates/interpreter/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm rename to crates/interpreter/tests/fixtures/switch/switch_inside_loop_continue_targets_loop.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_literal_union_default_narrows.subm b/crates/interpreter/tests/fixtures/switch/switch_literal_union_default_narrows.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_literal_union_default_narrows.subm rename to crates/interpreter/tests/fixtures/switch/switch_literal_union_default_narrows.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_literal_union_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/switch_literal_union_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_literal_union_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/switch_literal_union_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_multi_label.subm b/crates/interpreter/tests/fixtures/switch/switch_multi_label.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_multi_label.subm rename to crates/interpreter/tests/fixtures/switch/switch_multi_label.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_multi_label_discriminated.subm b/crates/interpreter/tests/fixtures/switch/switch_multi_label_discriminated.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_multi_label_discriminated.subm rename to crates/interpreter/tests/fixtures/switch/switch_multi_label_discriminated.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_multi_label_literal_union.subm b/crates/interpreter/tests/fixtures/switch/switch_multi_label_literal_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_multi_label_literal_union.subm rename to crates/interpreter/tests/fixtures/switch/switch_multi_label_literal_union.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_no_default.subm b/crates/interpreter/tests/fixtures/switch/switch_no_default.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_no_default.subm rename to crates/interpreter/tests/fixtures/switch/switch_no_default.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_number_basic.subm b/crates/interpreter/tests/fixtures/switch/switch_number_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_number_basic.subm rename to crates/interpreter/tests/fixtures/switch/switch_number_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_return_in_case.subm b/crates/interpreter/tests/fixtures/switch/switch_return_in_case.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_return_in_case.subm rename to crates/interpreter/tests/fixtures/switch/switch_return_in_case.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_string_basic.subm b/crates/interpreter/tests/fixtures/switch/switch_string_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_string_basic.subm rename to crates/interpreter/tests/fixtures/switch/switch_string_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/switch/switch_tuple_union_exhaustive.subm b/crates/interpreter/tests/fixtures/switch/switch_tuple_union_exhaustive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch/switch_tuple_union_exhaustive.subm rename to crates/interpreter/tests/fixtures/switch/switch_tuple_union_exhaustive.subm diff --git a/crates/submilli-engine/tests/fixtures/switch_case_body_recovery_no_panic.subm b/crates/interpreter/tests/fixtures/switch_case_body_recovery_no_panic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_case_body_recovery_no_panic.subm rename to crates/interpreter/tests/fixtures/switch_case_body_recovery_no_panic.subm diff --git a/crates/submilli-engine/tests/fixtures/switch_case_hex_literal.subm b/crates/interpreter/tests/fixtures/switch_case_hex_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_case_hex_literal.subm rename to crates/interpreter/tests/fixtures/switch_case_hex_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts b/crates/interpreter/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts rename to crates/interpreter/tests/fixtures/switch_case_null_absent_field_stays_reachable.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_expression_label_duplicates.ts b/crates/interpreter/tests/fixtures/switch_expression_label_duplicates.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_expression_label_duplicates.ts rename to crates/interpreter/tests/fixtures/switch_expression_label_duplicates.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_expression_labels.ts b/crates/interpreter/tests/fixtures/switch_expression_labels.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_expression_labels.ts rename to crates/interpreter/tests/fixtures/switch_expression_labels.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_function_declarations_hoisted.ts b/crates/interpreter/tests/fixtures/switch_function_declarations_hoisted.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_function_declarations_hoisted.ts rename to crates/interpreter/tests/fixtures/switch_function_declarations_hoisted.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_null_assignment_in_loop.ts b/crates/interpreter/tests/fixtures/switch_null_assignment_in_loop.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_null_assignment_in_loop.ts rename to crates/interpreter/tests/fixtures/switch_null_assignment_in_loop.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_nullable.ts b/crates/interpreter/tests/fixtures/switch_nullable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_nullable.ts rename to crates/interpreter/tests/fixtures/switch_nullable.ts diff --git a/crates/submilli-engine/tests/fixtures/switch_signed_number_labels.ts b/crates/interpreter/tests/fixtures/switch_signed_number_labels.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/switch_signed_number_labels.ts rename to crates/interpreter/tests/fixtures/switch_signed_number_labels.ts diff --git a/crates/submilli-engine/tests/fixtures/syntax_nesting_near_limit.ts b/crates/interpreter/tests/fixtures/syntax_nesting_near_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/syntax_nesting_near_limit.ts rename to crates/interpreter/tests/fixtures/syntax_nesting_near_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/template_generic_null.ts b/crates/interpreter/tests/fixtures/template_generic_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_generic_null.ts rename to crates/interpreter/tests/fixtures/template_generic_null.ts diff --git a/crates/submilli-engine/tests/fixtures/template_literal_boolean.subm b/crates/interpreter/tests/fixtures/template_literal_boolean.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_boolean.subm rename to crates/interpreter/tests/fixtures/template_literal_boolean.subm diff --git a/crates/submilli-engine/tests/fixtures/template_literal_interface.ts b/crates/interpreter/tests/fixtures/template_literal_interface.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_interface.ts rename to crates/interpreter/tests/fixtures/template_literal_interface.ts diff --git a/crates/submilli-engine/tests/fixtures/template_literal_nested.subm b/crates/interpreter/tests/fixtures/template_literal_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_nested.subm rename to crates/interpreter/tests/fixtures/template_literal_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/template_literal_no_substitution.subm b/crates/interpreter/tests/fixtures/template_literal_no_substitution.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_no_substitution.subm rename to crates/interpreter/tests/fixtures/template_literal_no_substitution.subm diff --git a/crates/submilli-engine/tests/fixtures/template_literal_non_null_assert.ts b/crates/interpreter/tests/fixtures/template_literal_non_null_assert.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_non_null_assert.ts rename to crates/interpreter/tests/fixtures/template_literal_non_null_assert.ts diff --git a/crates/submilli-engine/tests/fixtures/template_literal_nullish.ts b/crates/interpreter/tests/fixtures/template_literal_nullish.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_nullish.ts rename to crates/interpreter/tests/fixtures/template_literal_nullish.ts diff --git a/crates/submilli-engine/tests/fixtures/template_literal_number.subm b/crates/interpreter/tests/fixtures/template_literal_number.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_number.subm rename to crates/interpreter/tests/fixtures/template_literal_number.subm diff --git a/crates/submilli-engine/tests/fixtures/template_literal_string.subm b/crates/interpreter/tests/fixtures/template_literal_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_string.subm rename to crates/interpreter/tests/fixtures/template_literal_string.subm diff --git a/crates/submilli-engine/tests/fixtures/template_literal_tuple.ts b/crates/interpreter/tests/fixtures/template_literal_tuple.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_literal_tuple.ts rename to crates/interpreter/tests/fixtures/template_literal_tuple.ts diff --git a/crates/submilli-engine/tests/fixtures/template_nesting_near_limit.ts b/crates/interpreter/tests/fixtures/template_nesting_near_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_nesting_near_limit.ts rename to crates/interpreter/tests/fixtures/template_nesting_near_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/template_substitution_spans.ts b/crates/interpreter/tests/fixtures/template_substitution_spans.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/template_substitution_spans.ts rename to crates/interpreter/tests/fixtures/template_substitution_spans.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal/fields_bag_by_interface_type.ts b/crates/interpreter/tests/fixtures/temporal/fields_bag_by_interface_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal/fields_bag_by_interface_type.ts rename to crates/interpreter/tests/fixtures/temporal/fields_bag_by_interface_type.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_compare.subm b/crates/interpreter/tests/fixtures/temporal_compare.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_compare.subm rename to crates/interpreter/tests/fixtures/temporal_compare.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_compare_sort.subm b/crates/interpreter/tests/fixtures/temporal_compare_sort.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_compare_sort.subm rename to crates/interpreter/tests/fixtures/temporal_compare_sort.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_arithmetic.subm b/crates/interpreter/tests/fixtures/temporal_duration_arithmetic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_arithmetic.subm rename to crates/interpreter/tests/fixtures/temporal_duration_arithmetic.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_compare_from.subm b/crates/interpreter/tests/fixtures/temporal_duration_compare_from.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_compare_from.subm rename to crates/interpreter/tests/fixtures/temporal_duration_compare_from.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_from_iso.subm b/crates/interpreter/tests/fixtures/temporal_duration_from_iso.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_from_iso.subm rename to crates/interpreter/tests/fixtures/temporal_duration_from_iso.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_host_validation.ts b/crates/interpreter/tests/fixtures/temporal_duration_host_validation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_host_validation.ts rename to crates/interpreter/tests/fixtures/temporal_duration_host_validation.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_like_arg.subm b/crates/interpreter/tests/fixtures/temporal_duration_like_arg.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_like_arg.subm rename to crates/interpreter/tests/fixtures/temporal_duration_like_arg.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_object_literal.subm b/crates/interpreter/tests/fixtures/temporal_duration_object_literal.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_object_literal.subm rename to crates/interpreter/tests/fixtures/temporal_duration_object_literal.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_round_total.subm b/crates/interpreter/tests/fixtures/temporal_duration_round_total.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_round_total.subm rename to crates/interpreter/tests/fixtures/temporal_duration_round_total.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_sign.subm b/crates/interpreter/tests/fixtures/temporal_duration_sign.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_sign.subm rename to crates/interpreter/tests/fixtures/temporal_duration_sign.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_to_string_options.subm b/crates/interpreter/tests/fixtures/temporal_duration_to_string_options.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_to_string_options.subm rename to crates/interpreter/tests/fixtures/temporal_duration_to_string_options.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_with_abs_blank.subm b/crates/interpreter/tests/fixtures/temporal_duration_with_abs_blank.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_with_abs_blank.subm rename to crates/interpreter/tests/fixtures/temporal_duration_with_abs_blank.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_duration_zdt_anchor.subm b/crates/interpreter/tests/fixtures/temporal_duration_zdt_anchor.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_duration_zdt_anchor.subm rename to crates/interpreter/tests/fixtures/temporal_duration_zdt_anchor.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_error_messages.subm b/crates/interpreter/tests/fixtures/temporal_error_messages.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_error_messages.subm rename to crates/interpreter/tests/fixtures/temporal_error_messages.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_errors_are_catchable.subm b/crates/interpreter/tests/fixtures/temporal_errors_are_catchable.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_errors_are_catchable.subm rename to crates/interpreter/tests/fixtures/temporal_errors_are_catchable.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_getters.subm b/crates/interpreter/tests/fixtures/temporal_getters.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_getters.subm rename to crates/interpreter/tests/fixtures/temporal_getters.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_hook_contract.ts b/crates/interpreter/tests/fixtures/temporal_hook_contract.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_hook_contract.ts rename to crates/interpreter/tests/fixtures/temporal_hook_contract.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_arithmetic.subm b/crates/interpreter/tests/fixtures/temporal_instant_arithmetic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_arithmetic.subm rename to crates/interpreter/tests/fixtures/temporal_instant_arithmetic.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm b/crates/interpreter/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm rename to crates/interpreter/tests/fixtures/temporal_instant_epoch_nanos_bigint.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_equals.subm b/crates/interpreter/tests/fixtures/temporal_instant_equals.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_equals.subm rename to crates/interpreter/tests/fixtures/temporal_instant_equals.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_from_epoch.subm b/crates/interpreter/tests/fixtures/temporal_instant_from_epoch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_from_epoch.subm rename to crates/interpreter/tests/fixtures/temporal_instant_from_epoch.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_iso_round_trip.subm b/crates/interpreter/tests/fixtures/temporal_instant_iso_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_iso_round_trip.subm rename to crates/interpreter/tests/fixtures/temporal_instant_iso_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_instant_round.subm b/crates/interpreter/tests/fixtures/temporal_instant_round.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_instant_round.subm rename to crates/interpreter/tests/fixtures/temporal_instant_round.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_long_duration.subm b/crates/interpreter/tests/fixtures/temporal_long_duration.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_long_duration.subm rename to crates/interpreter/tests/fixtures/temporal_long_duration.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_negative_duration.subm b/crates/interpreter/tests/fixtures/temporal_negative_duration.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_negative_duration.subm rename to crates/interpreter/tests/fixtures/temporal_negative_duration.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_now_plain.subm b/crates/interpreter/tests/fixtures/temporal_now_plain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_now_plain.subm rename to crates/interpreter/tests/fixtures/temporal_now_plain.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_now_smoke.subm b/crates/interpreter/tests/fixtures/temporal_now_smoke.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_now_smoke.subm rename to crates/interpreter/tests/fixtures/temporal_now_smoke.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_now_time_zone_id.subm b/crates/interpreter/tests/fixtures/temporal_now_time_zone_id.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_now_time_zone_id.subm rename to crates/interpreter/tests/fixtures/temporal_now_time_zone_id.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_now_zoned_date_time_iso.subm b/crates/interpreter/tests/fixtures/temporal_now_zoned_date_time_iso.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_now_zoned_date_time_iso.subm rename to crates/interpreter/tests/fixtures/temporal_now_zoned_date_time_iso.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_numeric_range_validation.ts b/crates/interpreter/tests/fixtures/temporal_numeric_range_validation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_numeric_range_validation.ts rename to crates/interpreter/tests/fixtures/temporal_numeric_range_validation.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_options_interface_arg.ts b/crates/interpreter/tests/fixtures/temporal_options_interface_arg.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_options_interface_arg.ts rename to crates/interpreter/tests/fixtures/temporal_options_interface_arg.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_plain_arithmetic.subm b/crates/interpreter/tests/fixtures/temporal_plain_arithmetic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plain_arithmetic.subm rename to crates/interpreter/tests/fixtures/temporal_plain_arithmetic.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plain_erased_boundaries.ts b/crates/interpreter/tests/fixtures/temporal_plain_erased_boundaries.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plain_erased_boundaries.ts rename to crates/interpreter/tests/fixtures/temporal_plain_erased_boundaries.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm b/crates/interpreter/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm rename to crates/interpreter/tests/fixtures/temporal_plain_to_yearmonth_monthday.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plain_to_zoned.subm b/crates/interpreter/tests/fixtures/temporal_plain_to_zoned.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plain_to_zoned.subm rename to crates/interpreter/tests/fixtures/temporal_plain_to_zoned.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plaindate.subm b/crates/interpreter/tests/fixtures/temporal_plaindate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plaindate.subm rename to crates/interpreter/tests/fixtures/temporal_plaindate.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plaindate_to_plaindatetime.subm b/crates/interpreter/tests/fixtures/temporal_plaindate_to_plaindatetime.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plaindate_to_plaindatetime.subm rename to crates/interpreter/tests/fixtures/temporal_plaindate_to_plaindatetime.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plaindatetime.subm b/crates/interpreter/tests/fixtures/temporal_plaindatetime.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plaindatetime.subm rename to crates/interpreter/tests/fixtures/temporal_plaindatetime.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plainmonthday.subm b/crates/interpreter/tests/fixtures/temporal_plainmonthday.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plainmonthday.subm rename to crates/interpreter/tests/fixtures/temporal_plainmonthday.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plaintime.subm b/crates/interpreter/tests/fixtures/temporal_plaintime.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plaintime.subm rename to crates/interpreter/tests/fixtures/temporal_plaintime.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_plainyearmonth.subm b/crates/interpreter/tests/fixtures/temporal_plainyearmonth.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_plainyearmonth.subm rename to crates/interpreter/tests/fixtures/temporal_plainyearmonth.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_to_json.subm b/crates/interpreter/tests/fixtures/temporal_to_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_to_json.subm rename to crates/interpreter/tests/fixtures/temporal_to_json.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_until_options.subm b/crates/interpreter/tests/fixtures/temporal_until_options.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_until_options.subm rename to crates/interpreter/tests/fixtures/temporal_until_options.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_with.subm b/crates/interpreter/tests/fixtures/temporal_with.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_with.subm rename to crates/interpreter/tests/fixtures/temporal_with.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm b/crates/interpreter/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm rename to crates/interpreter/tests/fixtures/temporal_yearmonth_monthday_to_plaindate.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_alias_identity.ts b/crates/interpreter/tests/fixtures/temporal_zdt_alias_identity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_alias_identity.ts rename to crates/interpreter/tests/fixtures/temporal_zdt_alias_identity.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_dst_spring_forward.subm b/crates/interpreter/tests/fixtures/temporal_zdt_dst_spring_forward.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_dst_spring_forward.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_dst_spring_forward.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_equals.subm b/crates/interpreter/tests/fixtures/temporal_zdt_equals.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_equals.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_equals.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_from_iso.subm b/crates/interpreter/tests/fixtures/temporal_zdt_from_iso.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_from_iso.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_from_iso.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_host_complete.ts b/crates/interpreter/tests/fixtures/temporal_zdt_host_complete.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_host_complete.ts rename to crates/interpreter/tests/fixtures/temporal_zdt_host_complete.ts diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm b/crates/interpreter/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_missing_member_diagnostic.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_to_instant.subm b/crates/interpreter/tests/fixtures/temporal_zdt_to_instant.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_to_instant.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_to_instant.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_to_plain.subm b/crates/interpreter/tests/fixtures/temporal_zdt_to_plain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_to_plain.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_to_plain.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zdt_with_time_zone.subm b/crates/interpreter/tests/fixtures/temporal_zdt_with_time_zone.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zdt_with_time_zone.subm rename to crates/interpreter/tests/fixtures/temporal_zdt_with_time_zone.subm diff --git a/crates/submilli-engine/tests/fixtures/temporal_zoned_round_trip.subm b/crates/interpreter/tests/fixtures/temporal_zoned_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/temporal_zoned_round_trip.subm rename to crates/interpreter/tests/fixtures/temporal_zoned_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/expect_error_missing_colon.subm b/crates/interpreter/tests/fixtures/ternary/expect_error_missing_colon.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/expect_error_missing_colon.subm rename to crates/interpreter/tests/fixtures/ternary/expect_error_missing_colon.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/logical_branches.ts b/crates/interpreter/tests/fixtures/ternary/logical_branches.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/logical_branches.ts rename to crates/interpreter/tests/fixtures/ternary/logical_branches.ts diff --git a/crates/submilli-engine/tests/fixtures/ternary/narrowing.subm b/crates/interpreter/tests/fixtures/ternary/narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/narrowing.subm rename to crates/interpreter/tests/fixtures/ternary/narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/nested.subm b/crates/interpreter/tests/fixtures/ternary/nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/nested.subm rename to crates/interpreter/tests/fixtures/ternary/nested.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/simple.subm b/crates/interpreter/tests/fixtures/ternary/simple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/simple.subm rename to crates/interpreter/tests/fixtures/ternary/simple.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/truthiness_cond.subm b/crates/interpreter/tests/fixtures/ternary/truthiness_cond.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/truthiness_cond.subm rename to crates/interpreter/tests/fixtures/ternary/truthiness_cond.subm diff --git a/crates/submilli-engine/tests/fixtures/ternary/void_branches.ts b/crates/interpreter/tests/fixtures/ternary/void_branches.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/void_branches.ts rename to crates/interpreter/tests/fixtures/ternary/void_branches.ts diff --git a/crates/submilli-engine/tests/fixtures/ternary/with_optional_chain.subm b/crates/interpreter/tests/fixtures/ternary/with_optional_chain.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/ternary/with_optional_chain.subm rename to crates/interpreter/tests/fixtures/ternary/with_optional_chain.subm diff --git a/crates/submilli-engine/tests/fixtures/text_codec_unicode.subm b/crates/interpreter/tests/fixtures/text_codec_unicode.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/text_codec_unicode.subm rename to crates/interpreter/tests/fixtures/text_codec_unicode.subm diff --git a/crates/submilli-engine/tests/fixtures/text_codec_with_base64.subm b/crates/interpreter/tests/fixtures/text_codec_with_base64.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/text_codec_with_base64.subm rename to crates/interpreter/tests/fixtures/text_codec_with_base64.subm diff --git a/crates/submilli-engine/tests/fixtures/text_encoder_round_trip.subm b/crates/interpreter/tests/fixtures/text_encoder_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/text_encoder_round_trip.subm rename to crates/interpreter/tests/fixtures/text_encoder_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/to_json_record_non_string_throws.ts b/crates/interpreter/tests/fixtures/to_json_record_non_string_throws.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/to_json_record_non_string_throws.ts rename to crates/interpreter/tests/fixtures/to_json_record_non_string_throws.ts diff --git a/crates/submilli-engine/tests/fixtures/top_level_function_identity.ts b/crates/interpreter/tests/fixtures/top_level_function_identity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/top_level_function_identity.ts rename to crates/interpreter/tests/fixtures/top_level_function_identity.ts diff --git a/crates/submilli-engine/tests/fixtures/tostring_default_still_works.subm b/crates/interpreter/tests/fixtures/tostring_default_still_works.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tostring_default_still_works.subm rename to crates/interpreter/tests/fixtures/tostring_default_still_works.subm diff --git a/crates/submilli-engine/tests/fixtures/tostring_field_override.subm b/crates/interpreter/tests/fixtures/tostring_field_override.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tostring_field_override.subm rename to crates/interpreter/tests/fixtures/tostring_field_override.subm diff --git a/crates/submilli-engine/tests/fixtures/tostring_field_override_with_capture.subm b/crates/interpreter/tests/fixtures/tostring_field_override_with_capture.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tostring_field_override_with_capture.subm rename to crates/interpreter/tests/fixtures/tostring_field_override_with_capture.subm diff --git a/crates/submilli-engine/tests/fixtures/trailing_commas.subm b/crates/interpreter/tests/fixtures/trailing_commas.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/trailing_commas.subm rename to crates/interpreter/tests/fixtures/trailing_commas.subm diff --git a/crates/submilli-engine/tests/fixtures/truthiness/always_truthy.ts b/crates/interpreter/tests/fixtures/truthiness/always_truthy.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/always_truthy.ts rename to crates/interpreter/tests/fixtures/truthiness/always_truthy.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/and_value.ts b/crates/interpreter/tests/fixtures/truthiness/and_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/and_value.ts rename to crates/interpreter/tests/fixtures/truthiness/and_value.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/bigint_cond.ts b/crates/interpreter/tests/fixtures/truthiness/bigint_cond.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/bigint_cond.ts rename to crates/interpreter/tests/fixtures/truthiness/bigint_cond.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/boolean_or_null.ts b/crates/interpreter/tests/fixtures/truthiness/boolean_or_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/boolean_or_null.ts rename to crates/interpreter/tests/fixtures/truthiness/boolean_or_null.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/false_branch_keeps_type.ts b/crates/interpreter/tests/fixtures/truthiness/false_branch_keeps_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/false_branch_keeps_type.ts rename to crates/interpreter/tests/fixtures/truthiness/false_branch_keeps_type.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/logical_in_condition.ts b/crates/interpreter/tests/fixtures/truthiness/logical_in_condition.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/logical_in_condition.ts rename to crates/interpreter/tests/fixtures/truthiness/logical_in_condition.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/number_cond.ts b/crates/interpreter/tests/fixtures/truthiness/number_cond.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/number_cond.ts rename to crates/interpreter/tests/fixtures/truthiness/number_cond.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/or_default.ts b/crates/interpreter/tests/fixtures/truthiness/or_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/or_default.ts rename to crates/interpreter/tests/fixtures/truthiness/or_default.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/string_cond.ts b/crates/interpreter/tests/fixtures/truthiness/string_cond.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/string_cond.ts rename to crates/interpreter/tests/fixtures/truthiness/string_cond.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness/string_or_null_empty.ts b/crates/interpreter/tests/fixtures/truthiness/string_or_null_empty.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness/string_or_null_empty.ts rename to crates/interpreter/tests/fixtures/truthiness/string_or_null_empty.ts diff --git a/crates/submilli-engine/tests/fixtures/truthiness_rules_out_to_never.ts b/crates/interpreter/tests/fixtures/truthiness_rules_out_to_never.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/truthiness_rules_out_to_never.ts rename to crates/interpreter/tests/fixtures/truthiness_rules_out_to_never.ts diff --git a/crates/submilli-engine/tests/fixtures/ts_single.ts b/crates/interpreter/tests/fixtures/ts_single.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/ts_single.ts rename to crates/interpreter/tests/fixtures/ts_single.ts diff --git a/crates/submilli-engine/tests/fixtures/tuple_as_array.subm b/crates/interpreter/tests/fixtures/tuple_as_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_as_array.subm rename to crates/interpreter/tests/fixtures/tuple_as_array.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_as_iterable_source.ts b/crates/interpreter/tests/fixtures/tuple_as_iterable_source.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_as_iterable_source.ts rename to crates/interpreter/tests/fixtures/tuple_as_iterable_source.ts diff --git a/crates/submilli-engine/tests/fixtures/tuple_basic.subm b/crates/interpreter/tests/fixtures/tuple_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_basic.subm rename to crates/interpreter/tests/fixtures/tuple_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_in_array.subm b/crates/interpreter/tests/fixtures/tuple_in_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_in_array.subm rename to crates/interpreter/tests/fixtures/tuple_in_array.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_json_stringify.subm b/crates/interpreter/tests/fixtures/tuple_json_stringify.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_json_stringify.subm rename to crates/interpreter/tests/fixtures/tuple_json_stringify.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_labels.ts b/crates/interpreter/tests/fixtures/tuple_labels.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_labels.ts rename to crates/interpreter/tests/fixtures/tuple_labels.ts diff --git a/crates/submilli-engine/tests/fixtures/tuple_length.subm b/crates/interpreter/tests/fixtures/tuple_length.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_length.subm rename to crates/interpreter/tests/fixtures/tuple_length.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_methods.subm b/crates/interpreter/tests/fixtures/tuple_methods.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_methods.subm rename to crates/interpreter/tests/fixtures/tuple_methods.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_nested.subm b/crates/interpreter/tests/fixtures/tuple_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_nested.subm rename to crates/interpreter/tests/fixtures/tuple_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/tuple_union_index_access.subm b/crates/interpreter/tests/fixtures/tuple_union_index_access.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuple_union_index_access.subm rename to crates/interpreter/tests/fixtures/tuple_union_index_access.subm diff --git a/crates/submilli-engine/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts b/crates/interpreter/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts rename to crates/interpreter/tests/fixtures/tuples/expect_error_optional_to_required_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/tuples/issue_988_arity.ts b/crates/interpreter/tests/fixtures/tuples/issue_988_arity.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/issue_988_arity.ts rename to crates/interpreter/tests/fixtures/tuples/issue_988_arity.ts diff --git a/crates/submilli-engine/tests/fixtures/tuples/issue_988_correlation.ts b/crates/interpreter/tests/fixtures/tuples/issue_988_correlation.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/issue_988_correlation.ts rename to crates/interpreter/tests/fixtures/tuples/issue_988_correlation.ts diff --git a/crates/submilli-engine/tests/fixtures/tuples/issue_988_union_context.ts b/crates/interpreter/tests/fixtures/tuples/issue_988_union_context.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/issue_988_union_context.ts rename to crates/interpreter/tests/fixtures/tuples/issue_988_union_context.ts diff --git a/crates/submilli-engine/tests/fixtures/tuples/optional_elements.ts b/crates/interpreter/tests/fixtures/tuples/optional_elements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/optional_elements.ts rename to crates/interpreter/tests/fixtures/tuples/optional_elements.ts diff --git a/crates/submilli-engine/tests/fixtures/tuples/required_undefined_to_optional.ts b/crates/interpreter/tests/fixtures/tuples/required_undefined_to_optional.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/tuples/required_undefined_to_optional.ts rename to crates/interpreter/tests/fixtures/tuples/required_undefined_to_optional.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/alias_null_in_union.subm b/crates/interpreter/tests/fixtures/type-aliases/alias_null_in_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/alias_null_in_union.subm rename to crates/interpreter/tests/fixtures/type-aliases/alias_null_in_union.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/alias_string_host_call.subm b/crates/interpreter/tests/fixtures/type-aliases/alias_string_host_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/alias_string_host_call.subm rename to crates/interpreter/tests/fixtures/type-aliases/alias_string_host_call.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/alias_tuple_literal_return.ts b/crates/interpreter/tests/fixtures/type-aliases/alias_tuple_literal_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/alias_tuple_literal_return.ts rename to crates/interpreter/tests/fixtures/type-aliases/alias_tuple_literal_return.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/alias_union_dedup.ts b/crates/interpreter/tests/fixtures/type-aliases/alias_union_dedup.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/alias_union_dedup.ts rename to crates/interpreter/tests/fixtures/type-aliases/alias_union_dedup.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/aliased_function_type_const.subm b/crates/interpreter/tests/fixtures/type-aliases/aliased_function_type_const.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/aliased_function_type_const.subm rename to crates/interpreter/tests/fixtures/type-aliases/aliased_function_type_const.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_return.ts b/crates/interpreter/tests/fixtures/type-aliases/aliased_void_return.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_return.ts rename to crates/interpreter/tests/fixtures/type-aliases/aliased_void_return.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_value.ts b/crates/interpreter/tests/fixtures/type-aliases/aliased_void_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/aliased_void_value.ts rename to crates/interpreter/tests/fixtures/type-aliases/aliased_void_value.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_missing.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_generic_alias_arity_too_many.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_duplicate.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_generic_args.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_mismatch.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm b/crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm rename to crates/interpreter/tests/fixtures/type-aliases/expect_error_type_alias_unknown_body.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts b/crates/interpreter/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts rename to crates/interpreter/tests/fixtures/type-aliases/expect_warning_non_nullable_recursive_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_box.subm b/crates/interpreter/tests/fixtures/type-aliases/generic_alias_box.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_box.subm rename to crates/interpreter/tests/fixtures/type-aliases/generic_alias_box.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm b/crates/interpreter/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm rename to crates/interpreter/tests/fixtures/type-aliases/generic_alias_in_function_signature.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_nested.subm b/crates/interpreter/tests/fixtures/type-aliases/generic_alias_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_nested.subm rename to crates/interpreter/tests/fixtures/type-aliases/generic_alias_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_pair.subm b/crates/interpreter/tests/fixtures/type-aliases/generic_alias_pair.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/generic_alias_pair.subm rename to crates/interpreter/tests/fixtures/type-aliases/generic_alias_pair.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts b/crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts rename to crates/interpreter/tests/fixtures/type-aliases/mutually_recursive_alias_nullability.ts diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/non_generic_alias_nested.subm b/crates/interpreter/tests/fixtures/type-aliases/non_generic_alias_nested.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/non_generic_alias_nested.subm rename to crates/interpreter/tests/fixtures/type-aliases/non_generic_alias_nested.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_array.subm b/crates/interpreter/tests/fixtures/type-aliases/type_alias_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/type_alias_array.subm rename to crates/interpreter/tests/fixtures/type-aliases/type_alias_array.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_discriminated_union.subm b/crates/interpreter/tests/fixtures/type-aliases/type_alias_discriminated_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/type_alias_discriminated_union.subm rename to crates/interpreter/tests/fixtures/type-aliases/type_alias_discriminated_union.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_object.subm b/crates/interpreter/tests/fixtures/type-aliases/type_alias_object.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/type_alias_object.subm rename to crates/interpreter/tests/fixtures/type-aliases/type_alias_object.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_primitive.subm b/crates/interpreter/tests/fixtures/type-aliases/type_alias_primitive.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/type_alias_primitive.subm rename to crates/interpreter/tests/fixtures/type-aliases/type_alias_primitive.subm diff --git a/crates/submilli-engine/tests/fixtures/type-aliases/type_alias_union.subm b/crates/interpreter/tests/fixtures/type-aliases/type_alias_union.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/type-aliases/type_alias_union.subm rename to crates/interpreter/tests/fixtures/type-aliases/type_alias_union.subm diff --git a/crates/submilli-engine/tests/fixtures/type_guard_rendering_names_the_loss.ts b/crates/interpreter/tests/fixtures/type_guard_rendering_names_the_loss.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type_guard_rendering_names_the_loss.ts rename to crates/interpreter/tests/fixtures/type_guard_rendering_names_the_loss.ts diff --git a/crates/submilli-engine/tests/fixtures/type_member_line_breaks.ts b/crates/interpreter/tests/fixtures/type_member_line_breaks.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type_member_line_breaks.ts rename to crates/interpreter/tests/fixtures/type_member_line_breaks.ts diff --git a/crates/submilli-engine/tests/fixtures/type_members_named_like_keywords.ts b/crates/interpreter/tests/fixtures/type_members_named_like_keywords.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type_members_named_like_keywords.ts rename to crates/interpreter/tests/fixtures/type_members_named_like_keywords.ts diff --git a/crates/submilli-engine/tests/fixtures/type_size_near_limit.ts b/crates/interpreter/tests/fixtures/type_size_near_limit.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/type_size_near_limit.ts rename to crates/interpreter/tests/fixtures/type_size_near_limit.ts diff --git a/crates/submilli-engine/tests/fixtures/typeof_alone.subm b/crates/interpreter/tests/fixtures/typeof_alone.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/typeof_alone.subm rename to crates/interpreter/tests/fixtures/typeof_alone.subm diff --git a/crates/submilli-engine/tests/fixtures/typeof_enum_member.ts b/crates/interpreter/tests/fixtures/typeof_enum_member.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/typeof_enum_member.ts rename to crates/interpreter/tests/fixtures/typeof_enum_member.ts diff --git a/crates/submilli-engine/tests/fixtures/typeof_function_narrows_union.ts b/crates/interpreter/tests/fixtures/typeof_function_narrows_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/typeof_function_narrows_union.ts rename to crates/interpreter/tests/fixtures/typeof_function_narrows_union.ts diff --git a/crates/submilli-engine/tests/fixtures/typeof_type_query.ts b/crates/interpreter/tests/fixtures/typeof_type_query.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/typeof_type_query.ts rename to crates/interpreter/tests/fixtures/typeof_type_query.ts diff --git a/crates/submilli-engine/tests/fixtures/typeof_undefined_type_query.ts b/crates/interpreter/tests/fixtures/typeof_undefined_type_query.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/typeof_undefined_type_query.ts rename to crates/interpreter/tests/fixtures/typeof_undefined_type_query.ts diff --git a/crates/submilli-engine/tests/fixtures/types/expect_error_any_not_supported.ts b/crates/interpreter/tests/fixtures/types/expect_error_any_not_supported.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/types/expect_error_any_not_supported.ts rename to crates/interpreter/tests/fixtures/types/expect_error_any_not_supported.ts diff --git a/crates/submilli-engine/tests/fixtures/types/expect_error_bare_function_type_params.ts b/crates/interpreter/tests/fixtures/types/expect_error_bare_function_type_params.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/types/expect_error_bare_function_type_params.ts rename to crates/interpreter/tests/fixtures/types/expect_error_bare_function_type_params.ts diff --git a/crates/submilli-engine/tests/fixtures/types/expect_error_function_type_param_typo.ts b/crates/interpreter/tests/fixtures/types/expect_error_function_type_param_typo.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/types/expect_error_function_type_param_typo.ts rename to crates/interpreter/tests/fixtures/types/expect_error_function_type_param_typo.ts diff --git a/crates/submilli-engine/tests/fixtures/types/expect_error_unclosed_grouped_type.ts b/crates/interpreter/tests/fixtures/types/expect_error_unclosed_grouped_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/types/expect_error_unclosed_grouped_type.ts rename to crates/interpreter/tests/fixtures/types/expect_error_unclosed_grouped_type.ts diff --git a/crates/submilli-engine/tests/fixtures/types/parenthesized_type.ts b/crates/interpreter/tests/fixtures/types/parenthesized_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/types/parenthesized_type.ts rename to crates/interpreter/tests/fixtures/types/parenthesized_type.ts diff --git a/crates/submilli-engine/tests/fixtures/uint8array_alloc.subm b/crates/interpreter/tests/fixtures/uint8array_alloc.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_alloc.subm rename to crates/interpreter/tests/fixtures/uint8array_alloc.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_at.subm b/crates/interpreter/tests/fixtures/uint8array_at.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_at.subm rename to crates/interpreter/tests/fixtures/uint8array_at.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_base64.subm b/crates/interpreter/tests/fixtures/uint8array_base64.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_base64.subm rename to crates/interpreter/tests/fixtures/uint8array_base64.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_base64_options.subm b/crates/interpreter/tests/fixtures/uint8array_base64_options.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_base64_options.subm rename to crates/interpreter/tests/fixtures/uint8array_base64_options.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_byte_length.subm b/crates/interpreter/tests/fixtures/uint8array_byte_length.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_byte_length.subm rename to crates/interpreter/tests/fixtures/uint8array_byte_length.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_copy_within.subm b/crates/interpreter/tests/fixtures/uint8array_copy_within.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_copy_within.subm rename to crates/interpreter/tests/fixtures/uint8array_copy_within.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_equals.subm b/crates/interpreter/tests/fixtures/uint8array_equals.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_equals.subm rename to crates/interpreter/tests/fixtures/uint8array_equals.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_fill.subm b/crates/interpreter/tests/fixtures/uint8array_fill.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_fill.subm rename to crates/interpreter/tests/fixtures/uint8array_fill.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_filter.subm b/crates/interpreter/tests/fixtures/uint8array_filter.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_filter.subm rename to crates/interpreter/tests/fixtures/uint8array_filter.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_find.subm b/crates/interpreter/tests/fixtures/uint8array_find.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_find.subm rename to crates/interpreter/tests/fixtures/uint8array_find.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_for_each.subm b/crates/interpreter/tests/fixtures/uint8array_for_each.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_for_each.subm rename to crates/interpreter/tests/fixtures/uint8array_for_each.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_from_array.subm b/crates/interpreter/tests/fixtures/uint8array_from_array.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_from_array.subm rename to crates/interpreter/tests/fixtures/uint8array_from_array.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_from_bytes.subm b/crates/interpreter/tests/fixtures/uint8array_from_bytes.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_from_bytes.subm rename to crates/interpreter/tests/fixtures/uint8array_from_bytes.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_from_hex_errors.subm b/crates/interpreter/tests/fixtures/uint8array_from_hex_errors.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_from_hex_errors.subm rename to crates/interpreter/tests/fixtures/uint8array_from_hex_errors.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_hex.subm b/crates/interpreter/tests/fixtures/uint8array_hex.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_hex.subm rename to crates/interpreter/tests/fixtures/uint8array_hex.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_host_vtable.ts b/crates/interpreter/tests/fixtures/uint8array_host_vtable.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_host_vtable.ts rename to crates/interpreter/tests/fixtures/uint8array_host_vtable.ts diff --git a/crates/submilli-engine/tests/fixtures/uint8array_index_bounds.ts b/crates/interpreter/tests/fixtures/uint8array_index_bounds.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_index_bounds.ts rename to crates/interpreter/tests/fixtures/uint8array_index_bounds.ts diff --git a/crates/submilli-engine/tests/fixtures/uint8array_index_of.subm b/crates/interpreter/tests/fixtures/uint8array_index_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_index_of.subm rename to crates/interpreter/tests/fixtures/uint8array_index_of.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_indexed_write.subm b/crates/interpreter/tests/fixtures/uint8array_indexed_write.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_indexed_write.subm rename to crates/interpreter/tests/fixtures/uint8array_indexed_write.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_join.subm b/crates/interpreter/tests/fixtures/uint8array_join.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_join.subm rename to crates/interpreter/tests/fixtures/uint8array_join.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_map.subm b/crates/interpreter/tests/fixtures/uint8array_map.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_map.subm rename to crates/interpreter/tests/fixtures/uint8array_map.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_new.subm b/crates/interpreter/tests/fixtures/uint8array_new.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_new.subm rename to crates/interpreter/tests/fixtures/uint8array_new.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_new_length.ts b/crates/interpreter/tests/fixtures/uint8array_new_length.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_new_length.ts rename to crates/interpreter/tests/fixtures/uint8array_new_length.ts diff --git a/crates/submilli-engine/tests/fixtures/uint8array_of.subm b/crates/interpreter/tests/fixtures/uint8array_of.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_of.subm rename to crates/interpreter/tests/fixtures/uint8array_of.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_ranged_mutations.ts b/crates/interpreter/tests/fixtures/uint8array_ranged_mutations.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_ranged_mutations.ts rename to crates/interpreter/tests/fixtures/uint8array_ranged_mutations.ts diff --git a/crates/submilli-engine/tests/fixtures/uint8array_reduce.subm b/crates/interpreter/tests/fixtures/uint8array_reduce.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_reduce.subm rename to crates/interpreter/tests/fixtures/uint8array_reduce.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_reverse.subm b/crates/interpreter/tests/fixtures/uint8array_reverse.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_reverse.subm rename to crates/interpreter/tests/fixtures/uint8array_reverse.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_set.subm b/crates/interpreter/tests/fixtures/uint8array_set.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_set.subm rename to crates/interpreter/tests/fixtures/uint8array_set.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_set_out_of_range.subm b/crates/interpreter/tests/fixtures/uint8array_set_out_of_range.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_set_out_of_range.subm rename to crates/interpreter/tests/fixtures/uint8array_set_out_of_range.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_slice.subm b/crates/interpreter/tests/fixtures/uint8array_slice.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_slice.subm rename to crates/interpreter/tests/fixtures/uint8array_slice.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_some_every.subm b/crates/interpreter/tests/fixtures/uint8array_some_every.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_some_every.subm rename to crates/interpreter/tests/fixtures/uint8array_some_every.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_sort.subm b/crates/interpreter/tests/fixtures/uint8array_sort.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_sort.subm rename to crates/interpreter/tests/fixtures/uint8array_sort.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_subarray.subm b/crates/interpreter/tests/fixtures/uint8array_subarray.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_subarray.subm rename to crates/interpreter/tests/fixtures/uint8array_subarray.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_to_json.subm b/crates/interpreter/tests/fixtures/uint8array_to_json.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_to_json.subm rename to crates/interpreter/tests/fixtures/uint8array_to_json.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_to_reversed.subm b/crates/interpreter/tests/fixtures/uint8array_to_reversed.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_to_reversed.subm rename to crates/interpreter/tests/fixtures/uint8array_to_reversed.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_to_sorted.subm b/crates/interpreter/tests/fixtures/uint8array_to_sorted.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_to_sorted.subm rename to crates/interpreter/tests/fixtures/uint8array_to_sorted.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_to_string.subm b/crates/interpreter/tests/fixtures/uint8array_to_string.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_to_string.subm rename to crates/interpreter/tests/fixtures/uint8array_to_string.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_truncate.subm b/crates/interpreter/tests/fixtures/uint8array_truncate.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_truncate.subm rename to crates/interpreter/tests/fixtures/uint8array_truncate.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_with.subm b/crates/interpreter/tests/fixtures/uint8array_with.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_with.subm rename to crates/interpreter/tests/fixtures/uint8array_with.subm diff --git a/crates/submilli-engine/tests/fixtures/uint8array_wraps_like_to_uint8.ts b/crates/interpreter/tests/fixtures/uint8array_wraps_like_to_uint8.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uint8array_wraps_like_to_uint8.ts rename to crates/interpreter/tests/fixtures/uint8array_wraps_like_to_uint8.ts diff --git a/crates/submilli-engine/tests/fixtures/unary_plus_string.ts b/crates/interpreter/tests/fixtures/unary_plus_string.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unary_plus_string.ts rename to crates/interpreter/tests/fixtures/unary_plus_string.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/defaults.ts b/crates/interpreter/tests/fixtures/undefined/defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/defaults.ts rename to crates/interpreter/tests/fixtures/undefined/defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/expect_error_required.ts b/crates/interpreter/tests/fixtures/undefined/expect_error_required.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/expect_error_required.ts rename to crates/interpreter/tests/fixtures/undefined/expect_error_required.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/expect_error_required_argument.ts b/crates/interpreter/tests/fixtures/undefined/expect_error_required_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/expect_error_required_argument.ts rename to crates/interpreter/tests/fixtures/undefined/expect_error_required_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/methods.ts b/crates/interpreter/tests/fixtures/undefined/methods.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/methods.ts rename to crates/interpreter/tests/fixtures/undefined/methods.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/primitives.ts b/crates/interpreter/tests/fixtures/undefined/primitives.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/primitives.ts rename to crates/interpreter/tests/fixtures/undefined/primitives.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined/properties.ts b/crates/interpreter/tests/fixtures/undefined/properties.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined/properties.ts rename to crates/interpreter/tests/fixtures/undefined/properties.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_array_literal_elements.ts b/crates/interpreter/tests/fixtures/undefined_array_literal_elements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_array_literal_elements.ts rename to crates/interpreter/tests/fixtures/undefined_array_literal_elements.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_array_literal_nullish_lead.ts b/crates/interpreter/tests/fixtures/undefined_array_literal_nullish_lead.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_array_literal_nullish_lead.ts rename to crates/interpreter/tests/fixtures/undefined_array_literal_nullish_lead.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_base_constructor_order.ts b/crates/interpreter/tests/fixtures/undefined_base_constructor_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_base_constructor_order.ts rename to crates/interpreter/tests/fixtures/undefined_base_constructor_order.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts b/crates/interpreter/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts rename to crates/interpreter/tests/fixtures/undefined_binding_keeps_synthetic_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_class_method_alias.ts b/crates/interpreter/tests/fixtures/undefined_class_method_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_class_method_alias.ts rename to crates/interpreter/tests/fixtures/undefined_class_method_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_class_to_json_alias.ts b/crates/interpreter/tests/fixtures/undefined_class_to_json_alias.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_class_to_json_alias.ts rename to crates/interpreter/tests/fixtures/undefined_class_to_json_alias.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_closure_returns.ts b/crates/interpreter/tests/fixtures/undefined_closure_returns.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_closure_returns.ts rename to crates/interpreter/tests/fixtures/undefined_closure_returns.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_collections.ts b/crates/interpreter/tests/fixtures/undefined_collections.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_collections.ts rename to crates/interpreter/tests/fixtures/undefined_collections.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_default_parameter_write_type.ts b/crates/interpreter/tests/fixtures/undefined_default_parameter_write_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_default_parameter_write_type.ts rename to crates/interpreter/tests/fixtures/undefined_default_parameter_write_type.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_destructuring_defaults.ts b/crates/interpreter/tests/fixtures/undefined_destructuring_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_destructuring_defaults.ts rename to crates/interpreter/tests/fixtures/undefined_destructuring_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_function_optional_compatibility.ts b/crates/interpreter/tests/fixtures/undefined_function_optional_compatibility.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_function_optional_compatibility.ts rename to crates/interpreter/tests/fixtures/undefined_function_optional_compatibility.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_generic_union_inference.ts b/crates/interpreter/tests/fixtures/undefined_generic_union_inference.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_generic_union_inference.ts rename to crates/interpreter/tests/fixtures/undefined_generic_union_inference.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_inferred_parameter_defaults.ts b/crates/interpreter/tests/fixtures/undefined_inferred_parameter_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_inferred_parameter_defaults.ts rename to crates/interpreter/tests/fixtures/undefined_inferred_parameter_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_json.ts b/crates/interpreter/tests/fixtures/undefined_json.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_json.ts rename to crates/interpreter/tests/fixtures/undefined_json.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_later_destructured_parameter_capture.ts b/crates/interpreter/tests/fixtures/undefined_later_destructured_parameter_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_later_destructured_parameter_capture.ts rename to crates/interpreter/tests/fixtures/undefined_later_destructured_parameter_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_later_inferred_default.ts b/crates/interpreter/tests/fixtures/undefined_later_inferred_default.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_later_inferred_default.ts rename to crates/interpreter/tests/fixtures/undefined_later_inferred_default.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/default_parameter_truthiness.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_chain_null_guard_keeps_missing.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_effectful_undefined_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_null_guard_keeps_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_optional_discriminant_unequal.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_presence_keeps_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_discriminant_missing.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_switch_optional_field_missing.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_undefined_guard_keeps_null.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/expect_error_void_member_is_not_narrowed_away.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/guards.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/guards.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/guards.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/guards.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/nullish_discriminants.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/nullish_discriminants.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/nullish_discriminants.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/nullish_discriminants.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_chain.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/optional_chain.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_chain.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/optional_chain.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_shared_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/optional_discriminant_unequal.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_beside_tag.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/optional_literal_field_interfaces.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/singleton_comparisons.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/singleton_comparisons.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/singleton_comparisons.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/singleton_comparisons.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/switch_null_case_leaves_undefined.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/tuple_discriminant_undefined_position.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_narrowing/typeof_void.ts b/crates/interpreter/tests/fixtures/undefined_narrowing/typeof_void.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_narrowing/typeof_void.ts rename to crates/interpreter/tests/fixtures/undefined_narrowing/typeof_void.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_native_optional_methods.ts b/crates/interpreter/tests/fixtures/undefined_native_optional_methods.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_native_optional_methods.ts rename to crates/interpreter/tests/fixtures/undefined_native_optional_methods.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_optional_method_body.ts b/crates/interpreter/tests/fixtures/undefined_optional_method_body.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_optional_method_body.ts rename to crates/interpreter/tests/fixtures/undefined_optional_method_body.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_optional_method_implements.ts b/crates/interpreter/tests/fixtures/undefined_optional_method_implements.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_optional_method_implements.ts rename to crates/interpreter/tests/fixtures/undefined_optional_method_implements.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_default_source_types.ts b/crates/interpreter/tests/fixtures/undefined_parameter_default_source_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_default_source_types.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_default_source_types.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_default_tdz.ts b/crates/interpreter/tests/fixtures/undefined_parameter_default_tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_default_tdz.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_default_tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_defaults.ts b/crates/interpreter/tests/fixtures/undefined_parameter_defaults.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_defaults.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_defaults.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_destructuring_order.ts b/crates/interpreter/tests/fixtures/undefined_parameter_destructuring_order.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_destructuring_order.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_destructuring_order.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_capture.ts b/crates/interpreter/tests/fixtures/undefined_parameter_pattern_capture.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_capture.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_pattern_capture.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_literal_types.ts b/crates/interpreter/tests/fixtures/undefined_parameter_pattern_literal_types.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_literal_types.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_pattern_literal_types.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_write.ts b/crates/interpreter/tests/fixtures/undefined_parameter_pattern_write.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_pattern_write.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_pattern_write.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_property_declared_type.ts b/crates/interpreter/tests/fixtures/undefined_parameter_property_declared_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_property_declared_type.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_property_declared_type.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_property_inferred_type.ts b/crates/interpreter/tests/fixtures/undefined_parameter_property_inferred_type.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_property_inferred_type.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_property_inferred_type.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_parameter_tdz.ts b/crates/interpreter/tests/fixtures/undefined_parameter_tdz.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_parameter_tdz.ts rename to crates/interpreter/tests/fixtures/undefined_parameter_tdz.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_return_completion.ts b/crates/interpreter/tests/fixtures/undefined_return_completion.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_return_completion.ts rename to crates/interpreter/tests/fixtures/undefined_return_completion.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_runtime.ts b/crates/interpreter/tests/fixtures/undefined_runtime.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_runtime.ts rename to crates/interpreter/tests/fixtures/undefined_runtime.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_strings.ts b/crates/interpreter/tests/fixtures/undefined_strings.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_strings.ts rename to crates/interpreter/tests/fixtures/undefined_strings.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_temporal.ts b/crates/interpreter/tests/fixtures/undefined_temporal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_temporal.ts rename to crates/interpreter/tests/fixtures/undefined_temporal.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_tuple_spread.ts b/crates/interpreter/tests/fixtures/undefined_tuple_spread.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_tuple_spread.ts rename to crates/interpreter/tests/fixtures/undefined_tuple_spread.ts diff --git a/crates/submilli-engine/tests/fixtures/undefined_tuple_union.ts b/crates/interpreter/tests/fixtures/undefined_tuple_union.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/undefined_tuple_union.ts rename to crates/interpreter/tests/fixtures/undefined_tuple_union.ts diff --git a/crates/submilli-engine/tests/fixtures/unicode_whitespace_and_slash_escape.ts b/crates/interpreter/tests/fixtures/unicode_whitespace_and_slash_escape.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unicode_whitespace_and_slash_escape.ts rename to crates/interpreter/tests/fixtures/unicode_whitespace_and_slash_escape.ts diff --git a/crates/submilli-engine/tests/fixtures/union_cross_type_eq.subm b/crates/interpreter/tests/fixtures/union_cross_type_eq.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_cross_type_eq.subm rename to crates/interpreter/tests/fixtures/union_cross_type_eq.subm diff --git a/crates/submilli-engine/tests/fixtures/union_field_write_named_fix_round_trip.ts b/crates/interpreter/tests/fixtures/union_field_write_named_fix_round_trip.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_field_write_named_fix_round_trip.ts rename to crates/interpreter/tests/fixtures/union_field_write_named_fix_round_trip.ts diff --git a/crates/submilli-engine/tests/fixtures/union_field_write_names_the_fix.ts b/crates/interpreter/tests/fixtures/union_field_write_names_the_fix.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_field_write_names_the_fix.ts rename to crates/interpreter/tests/fixtures/union_field_write_names_the_fix.ts diff --git a/crates/submilli-engine/tests/fixtures/union_field_write_names_the_narrowing.ts b/crates/interpreter/tests/fixtures/union_field_write_names_the_narrowing.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_field_write_names_the_narrowing.ts rename to crates/interpreter/tests/fixtures/union_field_write_names_the_narrowing.ts diff --git a/crates/submilli-engine/tests/fixtures/union_field_write_non_union_receiver.ts b/crates/interpreter/tests/fixtures/union_field_write_non_union_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_field_write_non_union_receiver.ts rename to crates/interpreter/tests/fixtures/union_field_write_non_union_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/union_field_write_unnarrowable_receiver.ts b/crates/interpreter/tests/fixtures/union_field_write_unnarrowable_receiver.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_field_write_unnarrowable_receiver.ts rename to crates/interpreter/tests/fixtures/union_field_write_unnarrowable_receiver.ts diff --git a/crates/submilli-engine/tests/fixtures/union_literal_known_fields.ts b/crates/interpreter/tests/fixtures/union_literal_known_fields.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_literal_known_fields.ts rename to crates/interpreter/tests/fixtures/union_literal_known_fields.ts diff --git a/crates/submilli-engine/tests/fixtures/union_member_lowering_nullability.ts b/crates/interpreter/tests/fixtures/union_member_lowering_nullability.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_member_lowering_nullability.ts rename to crates/interpreter/tests/fixtures/union_member_lowering_nullability.ts diff --git a/crates/submilli-engine/tests/fixtures/union_primitive_eq.subm b/crates/interpreter/tests/fixtures/union_primitive_eq.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/union_primitive_eq.subm rename to crates/interpreter/tests/fixtures/union_primitive_eq.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/array_isarray.subm b/crates/interpreter/tests/fixtures/unknown/array_isarray.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/array_isarray.subm rename to crates/interpreter/tests/fixtures/unknown/array_isarray.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/array_isarray_null.subm b/crates/interpreter/tests/fixtures/unknown/array_isarray_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/array_isarray_null.subm rename to crates/interpreter/tests/fixtures/unknown/array_isarray_null.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/array_isarray_null_runtime.subm b/crates/interpreter/tests/fixtures/unknown/array_isarray_null_runtime.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/array_isarray_null_runtime.subm rename to crates/interpreter/tests/fixtures/unknown/array_isarray_null_runtime.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/closure_returns_null.subm b/crates/interpreter/tests/fixtures/unknown/closure_returns_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/closure_returns_null.subm rename to crates/interpreter/tests/fixtures/unknown/closure_returns_null.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/contextual_closure_returns_unknown.ts b/crates/interpreter/tests/fixtures/unknown/contextual_closure_returns_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/contextual_closure_returns_unknown.ts rename to crates/interpreter/tests/fixtures/unknown/contextual_closure_returns_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/eq_literal.ts b/crates/interpreter/tests/fixtures/unknown/eq_literal.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/eq_literal.ts rename to crates/interpreter/tests/fixtures/unknown/eq_literal.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/eq_null.subm b/crates/interpreter/tests/fixtures/unknown/eq_null.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/eq_null.subm rename to crates/interpreter/tests/fixtures/unknown/eq_null.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_and_or.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_and_or.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_and_or.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_and_or.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_arithmetic.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_arithmetic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_arithmetic.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_arithmetic.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_body_never_returns.ts b/crates/interpreter/tests/fixtures/unknown/expect_error_body_never_returns.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_body_never_returns.ts rename to crates/interpreter/tests/fixtures/unknown/expect_error_body_never_returns.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_call.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_call.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_call.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_call.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_field_access.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_field_access.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_field_access.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_field_access.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_index_access.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_index_access.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_index_access.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_index_access.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts b/crates/interpreter/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts rename to crates/interpreter/tests/fixtures/unknown/expect_error_non_null_assertion_stays_unknown.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_ordering.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_ordering.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_ordering.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_ordering.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/expect_error_truthiness.subm b/crates/interpreter/tests/fixtures/unknown/expect_error_truthiness.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/expect_error_truthiness.subm rename to crates/interpreter/tests/fixtures/unknown/expect_error_truthiness.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/generic_null_arg.subm b/crates/interpreter/tests/fixtures/unknown/generic_null_arg.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/generic_null_arg.subm rename to crates/interpreter/tests/fixtures/unknown/generic_null_arg.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/app/main.ts b/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/app/main.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/app/main.ts rename to crates/interpreter/tests/fixtures/unknown/no_value_cross_package/app/main.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts b/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts rename to crates/interpreter/tests/fixtures/unknown/no_value_cross_package/lib/lib.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/packages.manifest b/crates/interpreter/tests/fixtures/unknown/no_value_cross_package/packages.manifest similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/no_value_cross_package/packages.manifest rename to crates/interpreter/tests/fixtures/unknown/no_value_cross_package/packages.manifest diff --git a/crates/submilli-engine/tests/fixtures/unknown/no_value_returns_null.ts b/crates/interpreter/tests/fixtures/unknown/no_value_returns_null.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/no_value_returns_null.ts rename to crates/interpreter/tests/fixtures/unknown/no_value_returns_null.ts diff --git a/crates/submilli-engine/tests/fixtures/unknown/null_into_unknown.subm b/crates/interpreter/tests/fixtures/unknown/null_into_unknown.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/null_into_unknown.subm rename to crates/interpreter/tests/fixtures/unknown/null_into_unknown.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/parameter_round_trip.subm b/crates/interpreter/tests/fixtures/unknown/parameter_round_trip.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/parameter_round_trip.subm rename to crates/interpreter/tests/fixtures/unknown/parameter_round_trip.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/short_circuit.subm b/crates/interpreter/tests/fixtures/unknown/short_circuit.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/short_circuit.subm rename to crates/interpreter/tests/fixtures/unknown/short_circuit.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/tostring.subm b/crates/interpreter/tests/fixtures/unknown/tostring.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/tostring.subm rename to crates/interpreter/tests/fixtures/unknown/tostring.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown/typeof_narrowing.subm b/crates/interpreter/tests/fixtures/unknown/typeof_narrowing.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown/typeof_narrowing.subm rename to crates/interpreter/tests/fixtures/unknown/typeof_narrowing.subm diff --git a/crates/submilli-engine/tests/fixtures/unknown_array_null_element.ts b/crates/interpreter/tests/fixtures/unknown_array_null_element.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/unknown_array_null_element.ts rename to crates/interpreter/tests/fixtures/unknown_array_null_element.ts diff --git a/crates/submilli-engine/tests/fixtures/uri_encode_decode.subm b/crates/interpreter/tests/fixtures/uri_encode_decode.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/uri_encode_decode.subm rename to crates/interpreter/tests/fixtures/uri_encode_decode.subm diff --git a/crates/submilli-engine/tests/fixtures/uri_error_builtin.ts b/crates/interpreter/tests/fixtures/uri_error_builtin.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/uri_error_builtin.ts rename to crates/interpreter/tests/fixtures/uri_error_builtin.ts diff --git a/crates/submilli-engine/tests/fixtures/url/build_basic.subm b/crates/interpreter/tests/fixtures/url/build_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/build_basic.subm rename to crates/interpreter/tests/fixtures/url/build_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/url/build_host_only.ts b/crates/interpreter/tests/fixtures/url/build_host_only.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/build_host_only.ts rename to crates/interpreter/tests/fixtures/url/build_host_only.ts diff --git a/crates/submilli-engine/tests/fixtures/url/encode_decode_component.subm b/crates/interpreter/tests/fixtures/url/encode_decode_component.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/encode_decode_component.subm rename to crates/interpreter/tests/fixtures/url/encode_decode_component.subm diff --git a/crates/submilli-engine/tests/fixtures/url/encode_decode_query.subm b/crates/interpreter/tests/fixtures/url/encode_decode_query.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/encode_decode_query.subm rename to crates/interpreter/tests/fixtures/url/encode_decode_query.subm diff --git a/crates/submilli-engine/tests/fixtures/url/field_narrowing_guard.ts b/crates/interpreter/tests/fixtures/url/field_narrowing_guard.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/field_narrowing_guard.ts rename to crates/interpreter/tests/fixtures/url/field_narrowing_guard.ts diff --git a/crates/submilli-engine/tests/fixtures/url/parse_basic.subm b/crates/interpreter/tests/fixtures/url/parse_basic.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_basic.subm rename to crates/interpreter/tests/fixtures/url/parse_basic.subm diff --git a/crates/submilli-engine/tests/fixtures/url/parse_empty_query.subm b/crates/interpreter/tests/fixtures/url/parse_empty_query.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_empty_query.subm rename to crates/interpreter/tests/fixtures/url/parse_empty_query.subm diff --git a/crates/submilli-engine/tests/fixtures/url/parse_host_trailing_dot.ts b/crates/interpreter/tests/fixtures/url/parse_host_trailing_dot.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_host_trailing_dot.ts rename to crates/interpreter/tests/fixtures/url/parse_host_trailing_dot.ts diff --git a/crates/submilli-engine/tests/fixtures/url/parse_invalid_type_error.ts b/crates/interpreter/tests/fixtures/url/parse_invalid_type_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_invalid_type_error.ts rename to crates/interpreter/tests/fixtures/url/parse_invalid_type_error.ts diff --git a/crates/submilli-engine/tests/fixtures/url/parse_no_fragment.subm b/crates/interpreter/tests/fixtures/url/parse_no_fragment.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_no_fragment.subm rename to crates/interpreter/tests/fixtures/url/parse_no_fragment.subm diff --git a/crates/submilli-engine/tests/fixtures/url/parse_no_port.subm b/crates/interpreter/tests/fixtures/url/parse_no_port.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_no_port.subm rename to crates/interpreter/tests/fixtures/url/parse_no_port.subm diff --git a/crates/submilli-engine/tests/fixtures/url/parse_query_encoded.subm b/crates/interpreter/tests/fixtures/url/parse_query_encoded.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_query_encoded.subm rename to crates/interpreter/tests/fixtures/url/parse_query_encoded.subm diff --git a/crates/submilli-engine/tests/fixtures/url/parse_query_multiple.subm b/crates/interpreter/tests/fixtures/url/parse_query_multiple.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/parse_query_multiple.subm rename to crates/interpreter/tests/fixtures/url/parse_query_multiple.subm diff --git a/crates/submilli-engine/tests/fixtures/url/query_type_alias.subm b/crates/interpreter/tests/fixtures/url/query_type_alias.subm similarity index 100% rename from crates/submilli-engine/tests/fixtures/url/query_type_alias.subm rename to crates/interpreter/tests/fixtures/url/query_type_alias.subm diff --git a/crates/submilli-engine/tests/fixtures/void_accessor_nested_value.ts b/crates/interpreter/tests/fixtures/void_accessor_nested_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_accessor_nested_value.ts rename to crates/interpreter/tests/fixtures/void_accessor_nested_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_array_element_generic_value.ts b/crates/interpreter/tests/fixtures/void_array_element_generic_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_array_element_generic_value.ts rename to crates/interpreter/tests/fixtures/void_array_element_generic_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_array_element_shorthand_value.ts b/crates/interpreter/tests/fixtures/void_array_element_shorthand_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_array_element_shorthand_value.ts rename to crates/interpreter/tests/fixtures/void_array_element_shorthand_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_as_generic_arg_value.ts b/crates/interpreter/tests/fixtures/void_as_generic_arg_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_as_generic_arg_value.ts rename to crates/interpreter/tests/fixtures/void_as_generic_arg_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_behind_warning_value.ts b/crates/interpreter/tests/fixtures/void_behind_warning_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_behind_warning_value.ts rename to crates/interpreter/tests/fixtures/void_behind_warning_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_class_field_value.ts b/crates/interpreter/tests/fixtures/void_class_field_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_class_field_value.ts rename to crates/interpreter/tests/fixtures/void_class_field_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_class_static_field_value.ts b/crates/interpreter/tests/fixtures/void_class_static_field_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_class_static_field_value.ts rename to crates/interpreter/tests/fixtures/void_class_static_field_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_closure_param_value.ts b/crates/interpreter/tests/fixtures/void_closure_param_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_closure_param_value.ts rename to crates/interpreter/tests/fixtures/void_closure_param_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_conditional_cast_and_json_value.ts b/crates/interpreter/tests/fixtures/void_conditional_cast_and_json_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_conditional_cast_and_json_value.ts rename to crates/interpreter/tests/fixtures/void_conditional_cast_and_json_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_conditional_in_comparisons_value.ts b/crates/interpreter/tests/fixtures/void_conditional_in_comparisons_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_conditional_in_comparisons_value.ts rename to crates/interpreter/tests/fixtures/void_conditional_in_comparisons_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_equality_value.ts b/crates/interpreter/tests/fixtures/void_equality_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_equality_value.ts rename to crates/interpreter/tests/fixtures/void_equality_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_function_param_value.ts b/crates/interpreter/tests/fixtures/void_function_param_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_function_param_value.ts rename to crates/interpreter/tests/fixtures/void_function_param_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_function_type_alias_param_value.ts b/crates/interpreter/tests/fixtures/void_function_type_alias_param_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_function_type_alias_param_value.ts rename to crates/interpreter/tests/fixtures/void_function_type_alias_param_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_function_type_param_value.ts b/crates/interpreter/tests/fixtures/void_function_type_param_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_function_type_param_value.ts rename to crates/interpreter/tests/fixtures/void_function_type_param_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_hint_diverging_closure.ts b/crates/interpreter/tests/fixtures/void_hint_diverging_closure.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_hint_diverging_closure.ts rename to crates/interpreter/tests/fixtures/void_hint_diverging_closure.ts diff --git a/crates/submilli-engine/tests/fixtures/void_inferred_type_argument.ts b/crates/interpreter/tests/fixtures/void_inferred_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_inferred_type_argument.ts rename to crates/interpreter/tests/fixtures/void_inferred_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_interface_method_type_argument.ts b/crates/interpreter/tests/fixtures/void_interface_method_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_interface_method_type_argument.ts rename to crates/interpreter/tests/fixtures/void_interface_method_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_interface_property_value.ts b/crates/interpreter/tests/fixtures/void_interface_property_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_interface_property_value.ts rename to crates/interpreter/tests/fixtures/void_interface_property_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_interface_type_argument.ts b/crates/interpreter/tests/fixtures/void_interface_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_interface_type_argument.ts rename to crates/interpreter/tests/fixtures/void_interface_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_into_value_slot_value.ts b/crates/interpreter/tests/fixtures/void_into_value_slot_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_into_value_slot_value.ts rename to crates/interpreter/tests/fixtures/void_into_value_slot_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_literal_element_value.ts b/crates/interpreter/tests/fixtures/void_literal_element_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_literal_element_value.ts rename to crates/interpreter/tests/fixtures/void_literal_element_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts b/crates/interpreter/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts rename to crates/interpreter/tests/fixtures/void_nested_argument_does_not_hide_never_error.ts diff --git a/crates/submilli-engine/tests/fixtures/void_nullish_left_value.ts b/crates/interpreter/tests/fixtures/void_nullish_left_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_nullish_left_value.ts rename to crates/interpreter/tests/fixtures/void_nullish_left_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_object_field_type_value.ts b/crates/interpreter/tests/fixtures/void_object_field_type_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_object_field_type_value.ts rename to crates/interpreter/tests/fixtures/void_object_field_type_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_recursive_interface_type_argument.ts b/crates/interpreter/tests/fixtures/void_recursive_interface_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_recursive_interface_type_argument.ts rename to crates/interpreter/tests/fixtures/void_recursive_interface_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_recursive_permutation_type_argument.ts b/crates/interpreter/tests/fixtures/void_recursive_permutation_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_recursive_permutation_type_argument.ts rename to crates/interpreter/tests/fixtures/void_recursive_permutation_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_return_position.ts b/crates/interpreter/tests/fixtures/void_return_position.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_return_position.ts rename to crates/interpreter/tests/fixtures/void_return_position.ts diff --git a/crates/submilli-engine/tests/fixtures/void_return_type_argument.ts b/crates/interpreter/tests/fixtures/void_return_type_argument.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_return_type_argument.ts rename to crates/interpreter/tests/fixtures/void_return_type_argument.ts diff --git a/crates/submilli-engine/tests/fixtures/void_setter_param_value.ts b/crates/interpreter/tests/fixtures/void_setter_param_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_setter_param_value.ts rename to crates/interpreter/tests/fixtures/void_setter_param_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_switch_discriminant_value.ts b/crates/interpreter/tests/fixtures/void_switch_discriminant_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_switch_discriminant_value.ts rename to crates/interpreter/tests/fixtures/void_switch_discriminant_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_tuple_element_value.ts b/crates/interpreter/tests/fixtures/void_tuple_element_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_tuple_element_value.ts rename to crates/interpreter/tests/fixtures/void_tuple_element_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_union_condition.ts b/crates/interpreter/tests/fixtures/void_union_condition.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_union_condition.ts rename to crates/interpreter/tests/fixtures/void_union_condition.ts diff --git a/crates/submilli-engine/tests/fixtures/void_union_member_value.ts b/crates/interpreter/tests/fixtures/void_union_member_value.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_union_member_value.ts rename to crates/interpreter/tests/fixtures/void_union_member_value.ts diff --git a/crates/submilli-engine/tests/fixtures/void_value_annotations.ts b/crates/interpreter/tests/fixtures/void_value_annotations.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/void_value_annotations.ts rename to crates/interpreter/tests/fixtures/void_value_annotations.ts diff --git a/crates/submilli-engine/tests/fixtures/weak_type_shared_field.ts b/crates/interpreter/tests/fixtures/weak_type_shared_field.ts similarity index 100% rename from crates/submilli-engine/tests/fixtures/weak_type_shared_field.ts rename to crates/interpreter/tests/fixtures/weak_type_shared_field.ts diff --git a/crates/submilli-engine/tests/git_memory.rs b/crates/interpreter/tests/git_memory.rs similarity index 100% rename from crates/submilli-engine/tests/git_memory.rs rename to crates/interpreter/tests/git_memory.rs diff --git a/crates/submilli-engine/tests/host_memory.rs b/crates/interpreter/tests/host_memory.rs similarity index 100% rename from crates/submilli-engine/tests/host_memory.rs rename to crates/interpreter/tests/host_memory.rs diff --git a/crates/submilli-engine/tests/http_live.rs b/crates/interpreter/tests/http_live.rs similarity index 100% rename from crates/submilli-engine/tests/http_live.rs rename to crates/interpreter/tests/http_live.rs diff --git a/crates/submilli-engine/tests/http_live_fixtures/download_basic.subm b/crates/interpreter/tests/http_live_fixtures/download_basic.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/download_basic.subm rename to crates/interpreter/tests/http_live_fixtures/download_basic.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/download_gzip_decompress.subm b/crates/interpreter/tests/http_live_fixtures/download_gzip_decompress.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/download_gzip_decompress.subm rename to crates/interpreter/tests/http_live_fixtures/download_gzip_decompress.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/get_200_body.subm b/crates/interpreter/tests/http_live_fixtures/get_200_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/get_200_body.subm rename to crates/interpreter/tests/http_live_fixtures/get_200_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/get_404.subm b/crates/interpreter/tests/http_live_fixtures/get_404.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/get_404.subm rename to crates/interpreter/tests/http_live_fixtures/get_404.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/headers_authorization.subm b/crates/interpreter/tests/http_live_fixtures/headers_authorization.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/headers_authorization.subm rename to crates/interpreter/tests/http_live_fixtures/headers_authorization.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/headers_missing_auth_returns_404.subm b/crates/interpreter/tests/http_live_fixtures/headers_missing_auth_returns_404.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/headers_missing_auth_returns_404.subm rename to crates/interpreter/tests/http_live_fixtures/headers_missing_auth_returns_404.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/json_body.subm b/crates/interpreter/tests/http_live_fixtures/json_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/json_body.subm rename to crates/interpreter/tests/http_live_fixtures/json_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/json_method.subm b/crates/interpreter/tests/http_live_fixtures/json_method.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/json_method.subm rename to crates/interpreter/tests/http_live_fixtures/json_method.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_array_body.subm b/crates/interpreter/tests/http_live_fixtures/post_array_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_array_body.subm rename to crates/interpreter/tests/http_live_fixtures/post_array_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_null_body.subm b/crates/interpreter/tests/http_live_fixtures/post_null_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_null_body.subm rename to crates/interpreter/tests/http_live_fixtures/post_null_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_object_body.subm b/crates/interpreter/tests/http_live_fixtures/post_object_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_object_body.subm rename to crates/interpreter/tests/http_live_fixtures/post_object_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_object_body_custom_ct.subm b/crates/interpreter/tests/http_live_fixtures/post_object_body_custom_ct.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_object_body_custom_ct.subm rename to crates/interpreter/tests/http_live_fixtures/post_object_body_custom_ct.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_string_body.subm b/crates/interpreter/tests/http_live_fixtures/post_string_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_string_body.subm rename to crates/interpreter/tests/http_live_fixtures/post_string_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_uint8array_body.subm b/crates/interpreter/tests/http_live_fixtures/post_uint8array_body.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_uint8array_body.subm rename to crates/interpreter/tests/http_live_fixtures/post_uint8array_body.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/post_undefined_body.ts b/crates/interpreter/tests/http_live_fixtures/post_undefined_body.ts similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/post_undefined_body.ts rename to crates/interpreter/tests/http_live_fixtures/post_undefined_body.ts diff --git a/crates/submilli-engine/tests/http_live_fixtures/put_string_body_ct_override.subm b/crates/interpreter/tests/http_live_fixtures/put_string_body_ct_override.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/put_string_body_ct_override.subm rename to crates/interpreter/tests/http_live_fixtures/put_string_body_ct_override.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/request_runtime_verb.subm b/crates/interpreter/tests/http_live_fixtures/request_runtime_verb.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/request_runtime_verb.subm rename to crates/interpreter/tests/http_live_fixtures/request_runtime_verb.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/response_to_string.subm b/crates/interpreter/tests/http_live_fixtures/response_to_string.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/response_to_string.subm rename to crates/interpreter/tests/http_live_fixtures/response_to_string.subm diff --git a/crates/submilli-engine/tests/http_live_fixtures/verb_matrix.subm b/crates/interpreter/tests/http_live_fixtures/verb_matrix.subm similarity index 100% rename from crates/submilli-engine/tests/http_live_fixtures/verb_matrix.subm rename to crates/interpreter/tests/http_live_fixtures/verb_matrix.subm diff --git a/crates/submilli-engine/tests/http_tls_fixtures/ca.pem b/crates/interpreter/tests/http_tls_fixtures/ca.pem similarity index 100% rename from crates/submilli-engine/tests/http_tls_fixtures/ca.pem rename to crates/interpreter/tests/http_tls_fixtures/ca.pem diff --git a/crates/submilli-engine/tests/http_tls_fixtures/localhost-key.pem b/crates/interpreter/tests/http_tls_fixtures/localhost-key.pem similarity index 100% rename from crates/submilli-engine/tests/http_tls_fixtures/localhost-key.pem rename to crates/interpreter/tests/http_tls_fixtures/localhost-key.pem diff --git a/crates/submilli-engine/tests/http_tls_fixtures/localhost.pem b/crates/interpreter/tests/http_tls_fixtures/localhost.pem similarity index 100% rename from crates/submilli-engine/tests/http_tls_fixtures/localhost.pem rename to crates/interpreter/tests/http_tls_fixtures/localhost.pem diff --git a/crates/submilli-engine/tests/lexer_limits.rs b/crates/interpreter/tests/lexer_limits.rs similarity index 100% rename from crates/submilli-engine/tests/lexer_limits.rs rename to crates/interpreter/tests/lexer_limits.rs diff --git a/crates/submilli-engine/tests/memory_caps.rs b/crates/interpreter/tests/memory_caps.rs similarity index 100% rename from crates/submilli-engine/tests/memory_caps.rs rename to crates/interpreter/tests/memory_caps.rs diff --git a/crates/submilli-engine/tests/namespace_limits.rs b/crates/interpreter/tests/namespace_limits.rs similarity index 100% rename from crates/submilli-engine/tests/namespace_limits.rs rename to crates/interpreter/tests/namespace_limits.rs diff --git a/crates/submilli-engine/tests/object_vtable_dispatch.rs b/crates/interpreter/tests/object_vtable_dispatch.rs similarity index 100% rename from crates/submilli-engine/tests/object_vtable_dispatch.rs rename to crates/interpreter/tests/object_vtable_dispatch.rs diff --git a/crates/submilli-engine/tests/package_diagnostic_snapshots.rs b/crates/interpreter/tests/package_diagnostic_snapshots.rs similarity index 100% rename from crates/submilli-engine/tests/package_diagnostic_snapshots.rs rename to crates/interpreter/tests/package_diagnostic_snapshots.rs diff --git a/crates/submilli-engine/tests/parser_depth.rs b/crates/interpreter/tests/parser_depth.rs similarity index 100% rename from crates/submilli-engine/tests/parser_depth.rs rename to crates/interpreter/tests/parser_depth.rs diff --git a/crates/submilli-engine/tests/record_limits.rs b/crates/interpreter/tests/record_limits.rs similarity index 100% rename from crates/submilli-engine/tests/record_limits.rs rename to crates/interpreter/tests/record_limits.rs diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap similarity index 95% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap index e79bbbbd4..c649d9982 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_call_non_callable_lifts_number_interface.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 64 expression: "render_inside_main(\" let n: number = 42;\\n let r = n(1);\")" --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap similarity index 86% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap index a7ac199d0..7c1d53baf 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_dynamic_object_index.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 74 expression: "render_inside_main(\" let o = { a: 1 };\\n let k = \\\"a\\\";\\n let r = o[k];\")" --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap similarity index 84% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap index ee454486c..c064cfc76 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_field_not_found_on_object.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let p: { x: number; y: number } = { x: 1, y: 2 };\\n let z = p.z;\")" --- error: field `z` does not exist on `{ x: number; y: number }` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap similarity index 95% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap index 2ce896134..5332ff8c6 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b1_index_into_non_array.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 69 expression: "render_inside_main(\" let n: number = 42;\\n let r = n[0];\")" --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap similarity index 78% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap index a6eb43f53..7a1453856 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_call_arity_mismatch_lifts_anon_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected 2 argument(s), got 1 diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap similarity index 93% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap index 0036143db..e9b8ae59e 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_function_arg_unify_mismatch_lifts_signature_and_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: object literal has unknown field `z` for the target type diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap similarity index 92% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap index 6d89a3570..11afc1abf 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_generic_method_type_arg_arity_lifts_method_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n let ys = xs.map((x: number) => x.toString());\")" --- error: method `map` expects 1 type argument(s), got 2 diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap similarity index 90% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap index 0f6f0663a..c59b5b998 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_intrinsic_arity_lifts_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" parseInt();\")" --- error: expected 1-2 argument(s), got 0 diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap similarity index 87% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap index d204e1403..b9edf1232 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_method_arity_mismatch_lifts_method_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n xs.push();\")" --- error: method `push` expects 1 argument(s), got 0 diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap similarity index 79% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap index a451441be..3af023b70 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b2_number_coercion_type_mismatch_lifts_signature.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let x = Number(42);\")" --- error: expected `string | bigint | undefined`, got `number` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap similarity index 79% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap index d0bc79a28..6a1292e13 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unknown_type_suggests_close_builtin.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let n: numbre = 1;\")" --- error: unknown type `numbre` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap similarity index 83% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap index 1b486e632..30c0922f4 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_no_suggestion_when_no_close_match.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let pi: number = 3;\\n let q = absolutely_unrelated_name;\")" --- error: unresolved identifier `absolutely_unrelated_name` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap similarity index 80% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap index b1eb50707..1354b9a0e 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b3_unresolved_identifier_suggests_close_local.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let pi: number = 3;\\n let q = pi2;\")" --- error: unresolved identifier `pi2` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap similarity index 78% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap index fcee0bf57..f7a523258 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_cannot_infer_type_param_function_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `T`, got `null` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap similarity index 80% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap index a4b20e150..a15cf72a4 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_missing_initializer_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const x: number;\")" --- error: `const` declaration requires an initializer diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap similarity index 88% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap index bbc568789..d83ff3bb8 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_global_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\"const k: number = 1;\\nfunction main(): void { k = 2; }\\n\")" --- error: cannot assign to const binding `k` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap similarity index 86% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap index 067482627..9ef30821b 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_const_reassign_local_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const k = 1;\\n k = 2;\")" --- error: cannot assign to const binding `k` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap similarity index 85% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap index e68e42655..ae963cefc 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_function_reassign_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\"function f(): void { }\\nfunction main(): void { f = 1; }\\n\")" --- error: cannot assign to function `f` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap similarity index 86% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap index 044d66c56..2aa1d9664 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_let_missing_initializer_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 151 expression: "render_inside_main(\" let x: number;\")" --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap similarity index 74% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap index 3b2d9cb58..ffae592f4 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_main_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\" \\n\")" --- error: missing `main` function diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap similarity index 77% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap index d57d03a66..04941fad2 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_missing_return_type_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\"function main() { }\\n\")" --- error: expected `:` and return type diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap similarity index 89% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap index 267635bea..da2a3766d 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_param_missing_annotation_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\"function f(a): number { return a; }\\nfunction main(): void { }\\n\")" --- error: parameter requires a type annotation diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap similarity index 82% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap index aea8310d7..bb7c875f0 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_return_outside_function_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_all(\"function main(): void { }\\nreturn 1;\\n\")" --- error: `return` outside function diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap similarity index 82% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap index d3f38041c..b98777678 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b4_unknown_escape_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let s = \\\"hi\\\\q\\\";\")" --- error: unknown escape sequence `\q` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap similarity index 94% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap index 9f05d9e8c..65b834486 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_close_match_reported_at_each_field.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `number`, got `boolean` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap similarity index 94% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap index 14013ddb3..6c5162db3 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_fresh_object_literal_excess_field_help.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 235 expression: render_all(source) --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap similarity index 87% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap index e631117e1..d831994d6 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_function_type_assign_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" const g = (x: string) => true;\\n let f: (a: number, b: number) => boolean = g;\")" --- error: expected `(arg0: number, arg1: number) => boolean`, got `(arg0: string) => boolean` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap similarity index 92% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap index c0172aec4..2b981b3ee 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_boundary_diff_in_call.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 225 expression: render_all(source) --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap similarity index 78% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap index 49aca98fa..0479ea612 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__b5_object_field_assign_value_mismatch_diff.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected `string`, got `number` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap similarity index 82% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap index 9937ba022..890220845 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_duplicate_param_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: duplicate `@param a` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap similarity index 80% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap index fdc21b010..1282d6dec 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_missing_returns_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: missing `@returns` on a non-`void`-returning function diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap similarity index 88% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap index c6ed4c17f..18556d64b 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_param_name_mismatch_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@param wrong` does not match any parameter of this function diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap similarity index 79% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap index b6a30cee5..7a364259f 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_property_with_param_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@param wrong` on a property — properties have no parameters diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap similarity index 75% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap index d7e40919f..4d3772533 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_returns_on_void_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: `@returns` on a `void`-returning function diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap similarity index 84% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap index 9e19da547..5e527286c 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_surfaces_in_call_arity_lift.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: expected 2 argument(s), got 1 diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap similarity index 85% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap index 7888937a0..bf76e11a8 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__doc_unknown_tag_warns.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- warning: parameter `a` is undocumented (missing `@param a`) diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap similarity index 86% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap index 1024507b4..8cd24fb9c 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_duplicate_arm.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: duplicate `catch` clause for `ParseError` diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap similarity index 89% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap index e712953d1..4b81fe855 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__multi_catch_unreachable_arm.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: render_all(source) --- error: unreachable `catch` clause: `Derived` extends `Base`, which an earlier clause already catches diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap similarity index 90% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap index 8d4385af7..747b9d681 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__null_tostring_offers_fix_trio.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs assertion_line: 404 expression: "render_inside_main(\" const n = null;\\n let s = n.toString();\")" --- diff --git a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap b/crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap similarity index 87% rename from crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap rename to crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap index d204e1403..b9edf1232 100644 --- a/crates/submilli-engine/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap +++ b/crates/interpreter/tests/snapshots/diagnostic_snapshots__prelude_doc_surfaces_in_array_push_lift.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/diagnostic_snapshots.rs +source: crates/interpreter/tests/diagnostic_snapshots.rs expression: "render_inside_main(\" let xs: number[] = [1, 2, 3];\\n xs.push();\")" --- error: method `push` expects 1 argument(s), got 0 diff --git a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap similarity index 94% rename from crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap rename to crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap index 8f6b6f28a..4b5f06e61 100644 --- a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap +++ b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__caller_value_passed_on_after_the_check.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs +source: crates/interpreter/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\nfunction deliver(input: Input): void {}\n\n/**\n * Sends the message.\n * @param input Message and where to send it.\n * @capability test.com/send { channelId: string }\n */\nexport function send(input: Input): void {\n const channelId = input.channelId;\n check(\\\"test.com/send\\\", { channelId: channelId });\n deliver(input);\n deliver(input);\n}\n\")" --- warning: caller-supplied `input` is passed to `deliver` in `send`, which calls `check()` (and 1 more) diff --git a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap similarity index 94% rename from crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap rename to crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap index c241e42ac..6ce834052 100644 --- a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap +++ b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__check_in_a_function_the_package_does_not_export.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs +source: crates/interpreter/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\n/**\n * Approves the send.\n * @param channelId Conversation to post in.\n * @capability test.com/send { channelId: string }\n */\nfunction guard(channelId: string): void {\n check(\\\"test.com/send\\\", { channelId: channelId });\n}\n\n/**\n * Sends the message.\n * @param channelId Conversation to post in.\n * @param text Message text.\n */\nexport function send(channelId: string, text: string): void {\n guard(channelId);\n post(channelId, text);\n}\n\")" --- warning: `check()` is called in `guard`, which is not part of the package's public API diff --git a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap similarity index 95% rename from crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap rename to crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap index 0bd0ff2fd..8eada2ed9 100644 --- a/crates/submilli-engine/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap +++ b/crates/interpreter/tests/snapshots/package_diagnostic_snapshots__property_read_again_after_the_check.snap @@ -1,5 +1,5 @@ --- -source: crates/submilli-engine/tests/package_diagnostic_snapshots.rs +source: crates/interpreter/tests/package_diagnostic_snapshots.rs expression: "render_package(\"\n/**\n * Sends the message.\n * @param input Message and where to send it.\n * @capability test.com/send { channelId: string }\n */\nexport function send(input: Input): void {\n check(\\\"test.com/send\\\", { channelId: input.channelId });\n post(input.channelId, \\\"hello\\\");\n}\n\")" --- warning: `input.channelId` is read more than once in `send`, which calls `check()` diff --git a/crates/submilli-engine/tests/substitution_limits.rs b/crates/interpreter/tests/substitution_limits.rs similarity index 100% rename from crates/submilli-engine/tests/substitution_limits.rs rename to crates/interpreter/tests/substitution_limits.rs diff --git a/crates/submilli-engine/tests/traps_in_callbacks.rs b/crates/interpreter/tests/traps_in_callbacks.rs similarity index 100% rename from crates/submilli-engine/tests/traps_in_callbacks.rs rename to crates/interpreter/tests/traps_in_callbacks.rs diff --git a/crates/submilli-engine/tests/type_limits.rs b/crates/interpreter/tests/type_limits.rs similarity index 100% rename from crates/submilli-engine/tests/type_limits.rs rename to crates/interpreter/tests/type_limits.rs diff --git a/crates/submilli-engine/tests/vfs_containment.rs b/crates/interpreter/tests/vfs_containment.rs similarity index 100% rename from crates/submilli-engine/tests/vfs_containment.rs rename to crates/interpreter/tests/vfs_containment.rs diff --git a/crates/submilli-build/Cargo.toml b/crates/submilli-build/Cargo.toml index d2b667f2f..1d710a416 100644 --- a/crates/submilli-build/Cargo.toml +++ b/crates/submilli-build/Cargo.toml @@ -10,7 +10,7 @@ publish.workspace = true workspace = true [dependencies] -interpreter = { package = "submilli-engine", path = "../submilli-engine" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap deleted file mode 100644 index f5543fdb4..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__function_renders_arrow_form.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -(arg0: number, arg1: string) => boolean diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap deleted file mode 100644 index 77de6f710..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_optional_property.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Box { - label?: string; -} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap deleted file mode 100644 index f2e576e2e..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_renders_properties.snap +++ /dev/null @@ -1,8 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Item { - key: number; - tag: string; -} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap deleted file mode 100644 index 9c789d92d..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__interface_substitutes_property_generic.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Cell { - value: number; -} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap deleted file mode 100644 index 143194942..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__object_renders_structural_shape.snap +++ /dev/null @@ -1,8 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -{ - name: string; - x: number; -} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap deleted file mode 100644 index d12577e0e..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__format_definition__tests__primitive_with_declared_methods.snap +++ /dev/null @@ -1,7 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/format_definition.rs -expression: out ---- -interface Number { - toString(): string; -} diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap deleted file mode 100644 index 2970110c7..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_extra_field.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs -expression: out.unwrap() ---- -extra field(s): `y` diff --git a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap b/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap deleted file mode 100644 index 06e04df34..000000000 --- a/crates/submilli-engine/src/typechecker/infer/snapshots/submilli_engine__typechecker__infer__type_diff__tests__object_missing_field.snap +++ /dev/null @@ -1,5 +0,0 @@ ---- -source: crates/submilli-engine/src/typechecker/infer/type_diff.rs -expression: out.unwrap() ---- -missing field(s): `y` diff --git a/crates/submilli-policy/Cargo.toml b/crates/submilli-policy/Cargo.toml index 1ad739042..33c3e31fb 100644 --- a/crates/submilli-policy/Cargo.toml +++ b/crates/submilli-policy/Cargo.toml @@ -22,7 +22,7 @@ serde_json = { workspace = true } regex = { workspace = true } async-trait = { workspace = true } base64 = { workspace = true } -submilli-engine = { version = "0.3.0", path = "../submilli-engine", optional = true } +submilli-engine = { version = "0.3.0", path = "../interpreter", optional = true } url = { workspace = true, optional = true } [features] @@ -30,5 +30,5 @@ url = { workspace = true, optional = true } engine = ["dep:submilli-engine", "dep:url"] [dev-dependencies] -submilli-engine = { path = "../submilli-engine" } +submilli-engine = { path = "../interpreter" } tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/crates/submilli-server/Cargo.toml b/crates/submilli-server/Cargo.toml index 4729980f2..fb5c52b12 100644 --- a/crates/submilli-server/Cargo.toml +++ b/crates/submilli-server/Cargo.toml @@ -17,7 +17,7 @@ path = "src/main.rs" path = "src/lib.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../submilli-engine" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } diff --git a/crates/submilli-shared/Cargo.toml b/crates/submilli-shared/Cargo.toml index 1d866b15e..cca220dac 100644 --- a/crates/submilli-shared/Cargo.toml +++ b/crates/submilli-shared/Cargo.toml @@ -13,7 +13,7 @@ workspace = true path = "src/lib.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../submilli-engine" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-policy = { path = "../submilli-policy", features = ["engine"] } submilli-build = { path = "../submilli-build" } diff --git a/crates/submilli/Cargo.toml b/crates/submilli/Cargo.toml index b7573197c..1a0937d16 100644 --- a/crates/submilli/Cargo.toml +++ b/crates/submilli/Cargo.toml @@ -14,7 +14,7 @@ name = "submilli" path = "src/main.rs" [dependencies] -interpreter = { package = "submilli-engine", path = "../submilli-engine" } +interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } submilli-build = { path = "../submilli-build" } submilli-shared = { path = "../submilli-shared" } diff --git a/examples/docker/conformance.ts b/examples/docker/conformance.ts index f723097ae..e6899d39e 100644 --- a/examples/docker/conformance.ts +++ b/examples/docker/conformance.ts @@ -2,7 +2,7 @@ // against a running container by scripts/docker-conformance.sh. // // It deliberately does *not* re-prove language semantics. The fixture suite in -// crates/submilli-engine/tests/fixtures/ already does that, and those results cannot +// crates/interpreter/tests/fixtures/ already does that, and those results cannot // vary by environment: same WasmGC module, same Rust host functions, same answer // on a laptop and in distroless. What can vary is the boundary where the runtime // reaches out to the operating system — TLS trust, DNS, the timezone database, From 64aae70b74304de74ce369a80a89526f8c074480 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 19:36:24 +0300 Subject: [PATCH 09/10] Leave the standard-library reference page unchanged for now Co-Authored-By: Claude Opus 5.5 --- docs/part-6-reference/standard-library.md | 35 +---------------------- 1 file changed, 1 insertion(+), 34 deletions(-) diff --git a/docs/part-6-reference/standard-library.md b/docs/part-6-reference/standard-library.md index cb11ad8b2..b1a7b61e6 100644 --- a/docs/part-6-reference/standard-library.md +++ b/docs/part-6-reference/standard-library.md @@ -7,7 +7,7 @@ sidebar: authorship: label: ai-assisted confirmed: true - contentHash: "94d4d49e52c6614b6be56c086abc7229f7c932d7d35e01e81c1e040b21c461f3" + contentHash: "8b2e285130d62bdc705ab4f93500a9b8576133777739e04cec5e209f79462dd3" confirmedAt: "2026-10-09T15:40:52.000Z" --- @@ -199,39 +199,6 @@ whether the Package's caller may perform `capability` with the fields in `expectException(fn, errorType?)` checks that `fn` throws ([Write tests](/docs/packages/write-tests)). -## Modules a harness provides - -Two modules exist only where the harness running the program provides them. -The `submilli` CLI and server provide neither: importing one there fails with -``package `submilli:agents` is not available in this harness``, and neither is -listed by `submilli search` or in the sections below. - -| Module | What it does | Gated by | -| --- | --- | --- | -| `submilli:agents` | Sub-agents: `run(agent, input)`, `list()` | `agent.run`, on the field `agent` | -| `submilli:skills` | Skills: `list()`, `load(name)`, `readFile(name, path)` | `skill.load`, on the field `name` | - -- `run(agent, input)` returns the agent's final answer as text. With a type - argument it works like `llm.call`: the schema for `T` is sent with the - task. An answer that is not JSON throws `SyntaxError`, and one that does - not match `T` throws `TypeError`. -- The harness decides how long a run may take and what it may spend. The - execution timeout does not stop a run in progress. -- `list()` in either module leaves out what the policy denies the caller, - without saying how many were left out. -- `load(name)` and `readFile(name, path)` take a skill name as `list()` - returns it. A name that is empty, `.` or `..`, or contains `/`, `\` or - NUL throws `RangeError`. -- `readFile` takes a path relative to the skill, with `/` separators. A path - that is absolute, has an empty, `.` or `..` segment, or contains `\`, `:` - or NUL throws `RangeError`. Reading a file is gated by `skill.load` on the - skill's name. -- A name or path over 4096 bytes of UTF-8 throws `RangeError`. -- A name may contain `:`, as in `plugin:review`. Policy rules match names - exactly as written: `Review` is not `review`. -- With no provider configured, any call the checks above allow throws an - `Error` saying so. - ## `submilli:code` From 2a202b69c6800b42aa852554dc0bc11ef6b98be1 Mon Sep 17 00:00:00 2001 From: Doron Somech Date: Sat, 10 Oct 2026 20:46:41 +0300 Subject: [PATCH 10/10] Keep the policy engine in submilli-blueprint The engine never depended on the blueprint crate, so extracting submilli-policy is not needed for this change. The blueprint, shared, server and CLI sources go back to main; only the engine rename in their manifests and the resolve_permission doc comment fix remain. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/ci.yml | 8 +- AGENTS.md | 5 +- Cargo.lock | 16 - Cargo.toml | 1 - crates/interpreter/README.md | 4 +- .../interpreter/src/capability_derivation.rs | 3 +- crates/submilli-blueprint/Cargo.toml | 1 - crates/submilli-blueprint/src/auth_proxy.rs | 245 ++++++-- crates/submilli-blueprint/src/edit.rs | 9 +- crates/submilli-blueprint/src/endpoint.rs | 2 +- .../src/filter.rs | 21 +- crates/submilli-blueprint/src/lib.rs | 123 +++- crates/submilli-blueprint/src/maps.rs | 40 +- crates/submilli-blueprint/src/mcp.rs | 2 +- crates/submilli-blueprint/src/permissions.rs | 476 ++++++++++++++- crates/submilli-blueprint/src/variables.rs | 85 ++- crates/submilli-policy/Cargo.toml | 34 -- crates/submilli-policy/README.md | 15 - crates/submilli-policy/src/auth_proxy.rs | 271 --------- crates/submilli-policy/src/host.rs | 468 --------------- crates/submilli-policy/src/lib.rs | 40 -- crates/submilli-policy/src/permissions.rs | 557 ------------------ crates/submilli-policy/src/serde_support.rs | 124 ---- crates/submilli-policy/src/variables.rs | 86 --- .../tests/engine_literal_parity.rs | 68 --- .../submilli-server/src/handlers/execute.rs | 2 +- crates/submilli-server/src/mcp/server.rs | 6 +- .../tests/decision_records_policy.rs | 2 +- crates/submilli-server/tests/replay.rs | 2 +- crates/submilli-shared/Cargo.toml | 1 - crates/submilli-shared/src/host.rs | 455 +++++++++++--- crates/submilli/src/commands/run.rs | 5 +- 32 files changed, 1288 insertions(+), 1889 deletions(-) rename crates/{submilli-policy => submilli-blueprint}/src/filter.rs (99%) delete mode 100644 crates/submilli-policy/Cargo.toml delete mode 100644 crates/submilli-policy/README.md delete mode 100644 crates/submilli-policy/src/auth_proxy.rs delete mode 100644 crates/submilli-policy/src/host.rs delete mode 100644 crates/submilli-policy/src/lib.rs delete mode 100644 crates/submilli-policy/src/permissions.rs delete mode 100644 crates/submilli-policy/src/serde_support.rs delete mode 100644 crates/submilli-policy/src/variables.rs delete mode 100644 crates/submilli-policy/tests/engine_literal_parity.rs diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c8f441bde..33e424de0 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -38,11 +38,11 @@ jobs: - name: Clippy (gate) run: cargo clippy --workspace --all-targets -- -D warnings - # The engine and the policy crate are published to crates.io. Packaging - # builds them from the packaged files alone, so a source file left out of - # the package fails here rather than at release. + # The engine is published to crates.io. Packaging builds it from the + # packaged files alone, so a source file left out of the package fails + # here rather than at release. - name: Package for crates.io - run: cargo publish --dry-run --locked -p submilli-engine -p submilli-policy + run: cargo publish --dry-run --locked -p submilli-engine # The fixture harness defaults to a smoke subset (196 of 1054) for fast local # iteration. CI has no such constraint — the full sweep is a few seconds — and diff --git a/AGENTS.md b/AGENTS.md index 64feda709..93ff8e3ed 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -43,9 +43,8 @@ These rules govern `crates/submilli-server/src/domain/` and not make them domain concepts. Existing exceptions are not precedents. - **Domain is pure.** It owns business rules and state transitions, with no I/O, clock reads, or dependencies on server modules outside `domain`. It may depend - on the shared kernel, currently `submilli-blueprint` and the `submilli-policy` - types it is built on. Reuse its `Blueprint` type rather than introducing a - wrapper solely for storage concerns. + on the shared kernel, currently `submilli-blueprint`. Reuse its `Blueprint` + type rather than introducing a wrapper solely for storage concerns. - Aggregates protect their invariants through meaningful operations such as `close`, `expire`, `recover`, and `replace_credentials`. Application code calls those operations rather than changing fields directly. Names must describe diff --git a/Cargo.lock b/Cargo.lock index 3d2d9e3e7..5500ed56a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -5422,7 +5422,6 @@ dependencies = [ "serde_json", "serde_path_to_error", "serde_yml", - "submilli-policy", "tokio", "url", ] @@ -5491,20 +5490,6 @@ dependencies = [ "zstd", ] -[[package]] -name = "submilli-policy" -version = "0.3.0" -dependencies = [ - "async-trait", - "base64 0.22.1", - "regex", - "serde", - "serde_json", - "submilli-engine", - "tokio", - "url", -] - [[package]] name = "submilli-server" version = "0.3.0" @@ -5576,7 +5561,6 @@ dependencies = [ "submilli-blueprint", "submilli-build", "submilli-engine", - "submilli-policy", "tar", "tempfile", "tokio", diff --git a/Cargo.toml b/Cargo.toml index 591eb95a1..49f501b24 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,6 @@ members = [ "crates/submilli", "crates/submilli-build", "crates/submilli-blueprint", - "crates/submilli-policy", "crates/submilli-shared", "crates/submilli-server", ] diff --git a/crates/interpreter/README.md b/crates/interpreter/README.md index a9c9d5940..6f1ebba18 100644 --- a/crates/interpreter/README.md +++ b/crates/interpreter/README.md @@ -7,8 +7,6 @@ them in a sandbox where every effect goes through a capability check. An embedder chooses the standard library its programs see with `Stdlib`, and supplies the host services through traits on the store: the policy (`SecurityCheck`), HTTP, secrets, model calls (`LlmProvider`), sub-agents -(`AgentProvider`) and skills (`SkillProvider`), among others. The policy -engine that implements `SecurityCheck` from permission rules is -[`submilli-policy`](https://crates.io/crates/submilli-policy). +(`AgentProvider`) and skills (`SkillProvider`), among others. Licensed under Apache-2.0. diff --git a/crates/interpreter/src/capability_derivation.rs b/crates/interpreter/src/capability_derivation.rs index 26a40cfd5..7e413ce55 100644 --- a/crates/interpreter/src/capability_derivation.rs +++ b/crates/interpreter/src/capability_derivation.rs @@ -452,7 +452,8 @@ const VAR_PLACEHOLDER: &str = "${vars."; /// reads back as exactly `value`. `None` when no quoted string can spell it: the /// parser reads `${vars.` inside quotes as a variable reference. /// -/// Must agree with the policy crate's own quoting; a test there compares the two. +/// Must agree with `submilli-blueprint`'s `quote_literal`, which the engine +/// cannot depend on. #[doc(hidden)] pub fn filter_string_literal(value: &str) -> Option { (!value.contains(VAR_PLACEHOLDER)).then(|| format!("\"{}\"", escape(value))) diff --git a/crates/submilli-blueprint/Cargo.toml b/crates/submilli-blueprint/Cargo.toml index 8344d2afb..8ae3b3e84 100644 --- a/crates/submilli-blueprint/Cargo.toml +++ b/crates/submilli-blueprint/Cargo.toml @@ -13,7 +13,6 @@ workspace = true path = "src/lib.rs" [dependencies] -submilli-policy = { path = "../submilli-policy" } serde = { workspace = true, features = ["derive"] } serde_json = { workspace = true } serde_path_to_error = { workspace = true } diff --git a/crates/submilli-blueprint/src/auth_proxy.rs b/crates/submilli-blueprint/src/auth_proxy.rs index 0b9216c91..6fb9637c5 100644 --- a/crates/submilli-blueprint/src/auth_proxy.rs +++ b/crates/submilli-blueprint/src/auth_proxy.rs @@ -1,71 +1,224 @@ -//! The blueprint `auth_proxy:` block. The rules and their resolution live in -//! `submilli-policy`; this ties them to the blueprint's `secrets:` block — -//! a `${secrets.X}` must name a declared secret, resolved from where the -//! declaration says — and validates the rules with the YAML path of the -//! offending key. +//! The blueprint `auth_proxy:` block — host-keyed rules that inject auth +//! headers / query params into outbound HTTP, with `${secrets.X}` resolved from +//! the `secrets:` block. The script never sees the resolved values. +//! +//! This module is interpreter-free: it parses + validates the rules and, given +//! a [`SecretResolver`], computes what to inject. The embedder (`submilli-server`) +//! supplies the resolver and adapts the result to the runtime's `AuthProxy` trait. -use submilli_policy::{AuthError, AuthSpec, Injections, SecretResolver, secret_refs}; +use std::collections::BTreeMap; +use std::fmt; + +use base64::{Engine as _, engine::general_purpose::STANDARD}; +use serde::{Deserialize, Serialize}; use crate::{Blueprint, BlueprintError, Fault, SecretSource, yaml_path}; -/// Resolves a declared secret from its declaration's source. Implemented by the -/// embedder (store or harness). Async so a `store:` source can `await` the +const PLACEHOLDER_PREFIX: &str = "${secrets."; + +/// One host-keyed injection rule. v1 matches `host` exactly. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AuthProxyRule { + pub host: String, + /// Also requires the blueprint-wide opt-in to permit cleartext requests. + #[serde(default, skip_serializing_if = "std::ops::Not::not")] + pub allow_insecure_http: bool, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub auth: Option, + #[serde( + default, + skip_serializing_if = "BTreeMap::is_empty", + deserialize_with = "crate::maps::deserialize" + )] + pub headers: BTreeMap, + #[serde( + default, + skip_serializing_if = "BTreeMap::is_empty", + deserialize_with = "crate::maps::deserialize" + )] + pub query: BTreeMap, +} + +/// A first-class auth method, lowered into an `Authorization` header at resolve +/// time. Exactly one of `bearer`/`basic` is set (enforced by validation). +/// `bearer` / basic `password` name declared secrets; basic `username` is a +/// literal. Basic auth can't be expressed as an interpolation-only header value — +/// its `base64(user:pass)` is computed *after* the password secret resolves. +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct AuthSpec { + #[serde(default, skip_serializing_if = "Option::is_none")] + pub bearer: Option, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub basic: Option, +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct BasicAuth { + pub username: String, + pub password: String, +} + +/// Resolves a declared secret to its value. Implemented by the embedder +/// (store or harness). Async so a `store:` source can `await` the /// `SecretStore` without blocking the executor. #[async_trait::async_trait] -pub trait SourceSecretResolver: Sync { +pub trait SecretResolver: Sync { async fn resolve(&self, name: &str, source: &SecretSource) -> Result; } -/// A blueprint's declared secrets as a policy [`SecretResolver`]: a name the -/// `secrets:` block does not declare is [`AuthError::UndeclaredSecret`], and a -/// declared one resolves from its source through `inner`. -pub struct DeclaredSecrets<'a> { - pub blueprint: &'a Blueprint, - pub inner: &'a dyn SourceSecretResolver, +/// What an auth-proxy rule contributes to a request. Header/query *names* are +/// taken verbatim; values have their `${secrets.X}` placeholders resolved. +#[derive(Debug, Clone, PartialEq, Eq, Default)] +pub struct Injections { + pub headers: Vec<(String, String)>, + pub query: Vec<(String, String)>, } -#[async_trait::async_trait] -impl SecretResolver for DeclaredSecrets<'_> { - async fn resolve(&self, name: &str) -> Result { - let source = self - .blueprint - .secrets - .get(name) - .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; - self.inner.resolve(name, source).await +/// Runtime auth-proxy failure. Maps onto the runtime's `AuthProxyError`. +#[derive(Debug)] +pub enum AuthError { + /// `${secrets.X}` referenced a name not in the `secrets:` block. (Caught at + /// parse time too; this guards a resolver fed a stale blueprint.) + UndeclaredSecret(String), + /// Secret declared but its source produced no value. + MissingSecret(String), + Other(String), +} + +impl fmt::Display for AuthError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AuthError::UndeclaredSecret(name) => write!(f, "undeclared secret '{name}'"), + AuthError::MissingSecret(name) => write!(f, "missing secret '{name}'"), + AuthError::Other(msg) => f.write_str(msg), + } + } +} + +impl std::error::Error for AuthError {} + +/// The `${secrets.NAME}` names referenced by a value, in order. +pub fn secret_refs(value: &str) -> Vec<&str> { + let mut names = Vec::new(); + let mut rest = value; + while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { + let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; + match after.find('}') { + Some(end) => { + names.push(&after[..end]); + rest = &after[end + 1..]; + } + None => break, + } } + names } -/// [`submilli_policy::resolve_injections`] for a blueprint: the first -/// `auth_proxy` rule whose `host` matches exactly, with -/// `${secrets.X}` resolved against the declared secrets. `Ok(None)` when no -/// rule matches. +/// The first rule whose `host` matches exactly, with `${secrets.X}` resolved. +/// `Ok(None)` when no rule matches. pub async fn resolve_injections( blueprint: &Blueprint, host: &str, - resolver: &dyn SourceSecretResolver, + resolver: &dyn SecretResolver, ) -> Result, AuthError> { - let secrets = DeclaredSecrets { - blueprint, - inner: resolver, + let Some(rule) = blueprint.auth_proxy.iter().find(|r| r.host == host) else { + return Ok(None); }; - submilli_policy::resolve_injections(&blueprint.auth_proxy, host, &secrets).await + let mut headers = interpolate_pairs(&rule.headers, blueprint, resolver).await?; + if let Some(auth) = &rule.auth { + headers.push(( + "Authorization".to_string(), + resolve_authorization(auth, blueprint, resolver).await?, + )); + } + Ok(Some(Injections { + headers, + query: interpolate_pairs(&rule.query, blueprint, resolver).await?, + })) +} + +/// The `Authorization` header value for an `auth:` method: `Bearer ` or +/// `Basic `. `bearer`/`password` name declared secrets and +/// are resolved directly (not `${secrets.X}` interpolation). +async fn resolve_authorization( + auth: &AuthSpec, + blueprint: &Blueprint, + resolver: &dyn SecretResolver, +) -> Result { + if let Some(secret) = &auth.bearer { + return Ok(format!( + "Bearer {}", + resolve_secret(secret, blueprint, resolver).await? + )); + } + if let Some(basic) = &auth.basic { + let password = resolve_secret(&basic.password, blueprint, resolver).await?; + let token = STANDARD.encode(format!("{}:{password}", basic.username)); + return Ok(format!("Basic {token}")); + } + // Unreachable after validation, which requires exactly one method. + Err(AuthError::Other( + "auth_proxy rule has an empty `auth:` block".into(), + )) +} + +/// Resolve a declared secret by name (as opposed to `${secrets.X}` placeholders +/// inside a value string). +async fn resolve_secret( + name: &str, + blueprint: &Blueprint, + resolver: &dyn SecretResolver, +) -> Result { + let source = blueprint + .secrets + .get(name) + .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; + resolver.resolve(name, source).await } -/// [`submilli_policy::interpolate`] for a blueprint: replace every -/// `${secrets.NAME}` in `value` with its resolved declared secret. Public so +async fn interpolate_pairs( + pairs: &BTreeMap, + blueprint: &Blueprint, + resolver: &dyn SecretResolver, +) -> Result, AuthError> { + let mut out = Vec::with_capacity(pairs.len()); + for (name, value) in pairs { + out.push((name.clone(), interpolate(value, blueprint, resolver).await?)); + } + Ok(out) +} + +/// Replace every `${secrets.NAME}` in `value` with its resolved secret. Public so /// other blueprint blocks that interpolate secrets (e.g. the `mcp:` OAuth -/// `client_id`) reuse the exact placeholder semantics `auth_proxy` uses. +/// `client_id`) can reuse the exact placeholder semantics `auth_proxy` uses. pub async fn interpolate( value: &str, blueprint: &Blueprint, - resolver: &dyn SourceSecretResolver, + resolver: &dyn SecretResolver, ) -> Result { - let secrets = DeclaredSecrets { - blueprint, - inner: resolver, - }; - submilli_policy::interpolate(value, &secrets).await + let mut out = String::new(); + let mut rest = value; + while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { + out.push_str(&rest[..start]); + let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; + let end = after.find('}').ok_or_else(|| { + AuthError::Other(format!( + "unterminated '{PLACEHOLDER_PREFIX}...}}' in '{value}'" + )) + })?; + let name = &after[..end]; + let source = blueprint + .secrets + .get(name) + .ok_or_else(|| AuthError::UndeclaredSecret(name.to_string()))?; + out.push_str(&resolver.resolve(name, source).await?); + rest = &after[end + 1..]; + } + out.push_str(rest); + Ok(out) } /// Resolve **every declared secret**, to verify (at blueprint apply/add time) @@ -73,10 +226,10 @@ pub async fn interpolate( /// `auth_proxy:` — the `secrets:` block is the operator's declaration of what /// exists in this sandbox, so all of it is checked (whether or not auth_proxy /// references it). Point-in-time only: a later deletion from the store is the -/// runtime's concern, not a reason to reject the registration. IO lives in the embedder's [`SourceSecretResolver`]. +/// runtime's concern, not a reason to reject the registration. IO lives in the embedder's [`SecretResolver`]. pub async fn verify_secrets( blueprint: &Blueprint, - resolver: &dyn SourceSecretResolver, + resolver: &dyn SecretResolver, ) -> Result<(), AuthError> { for (name, source) in &blueprint.secrets { // Harness secrets are bound when a session opens — there is nothing to @@ -176,8 +329,6 @@ fn auth_secret_refs(auth: &AuthSpec) -> Vec<&str> { #[cfg(test)] mod tests { - use base64::{Engine as _, engine::general_purpose::STANDARD}; - use super::*; use crate::parse; @@ -186,7 +337,7 @@ mod tests { missing: Option<&'static str>, } #[async_trait::async_trait] - impl SourceSecretResolver for StubResolver { + impl SecretResolver for StubResolver { async fn resolve(&self, name: &str, _src: &SecretSource) -> Result { if self.missing == Some(name) { return Err(AuthError::MissingSecret(name.to_string())); diff --git a/crates/submilli-blueprint/src/edit.rs b/crates/submilli-blueprint/src/edit.rs index 16218e4ae..e53e58def 100644 --- a/crates/submilli-blueprint/src/edit.rs +++ b/crates/submilli-blueprint/src/edit.rs @@ -25,12 +25,9 @@ use std::ops::RangeInclusive; use serde_json::Value; -use submilli_policy::filter_syntax as filter; - -use crate::{ - Action, Blueprint, BlueprintError, PermissionRule, ResolutionCause, RuleRef, VarBindings, - VariableDecl, -}; +use crate::filter::{self, VarBindings}; +use crate::permissions::{Action, PermissionRule, ResolutionCause, RuleRef}; +use crate::{Blueprint, BlueprintError, VariableDecl}; /// The refused call a rule is drafted from. #[derive(Debug, Clone, Copy)] diff --git a/crates/submilli-blueprint/src/endpoint.rs b/crates/submilli-blueprint/src/endpoint.rs index 6d21d12cc..3c2e02201 100644 --- a/crates/submilli-blueprint/src/endpoint.rs +++ b/crates/submilli-blueprint/src/endpoint.rs @@ -12,8 +12,8 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; use url::Url; +use crate::auth_proxy::secret_refs; use crate::{Blueprint, Fault, FieldMatch, yaml_path}; -use submilli_policy::secret_refs; /// Host names that always mean this machine, whatever DNS says. Mirrors the /// loopback set the server's MCP endpoint keeps diff --git a/crates/submilli-policy/src/filter.rs b/crates/submilli-blueprint/src/filter.rs similarity index 99% rename from crates/submilli-policy/src/filter.rs rename to crates/submilli-blueprint/src/filter.rs index 5d47252db..c59fe1f97 100644 --- a/crates/submilli-policy/src/filter.rs +++ b/crates/submilli-blueprint/src/filter.rs @@ -308,8 +308,7 @@ impl FilterExpr { /// The top-level `and` operands, flattened: `a and (b and c)` yields `a`, `b`, /// `c`. A filter that is not an `and` is its own single conjunct. - #[doc(hidden)] - pub fn conjuncts(&self) -> Vec<&FilterExpr> { + pub(crate) fn conjuncts(&self) -> Vec<&FilterExpr> { let mut out = Vec::new(); self.collect_flat(&mut out, |expr| match expr { Expr::And(left, right) => Some((left, right)), @@ -319,8 +318,7 @@ impl FilterExpr { } /// The top-level `or` operands, flattened like [`Self::conjuncts`]. - #[doc(hidden)] - pub fn disjuncts(&self) -> Vec<&FilterExpr> { + pub(crate) fn disjuncts(&self) -> Vec<&FilterExpr> { let mut out = Vec::new(); self.collect_flat(&mut out, |expr| match expr { Expr::Or(left, right) => Some((left, right)), @@ -345,8 +343,7 @@ impl FilterExpr { /// `(field path, variable)` when this expression is exactly /// `field == ${vars.NAME}`: the shape that pins a rule to a session variable. - #[doc(hidden)] - pub fn as_pin(&self) -> Option<(String, &str)> { + pub(crate) fn as_pin(&self) -> Option<(String, &str)> { match &self.0 { Expr::Compare(Comparison { path, @@ -724,15 +721,13 @@ fn glob_token(pat: &[char], pi: usize) -> Option<(GlobToken, usize)> { /// `value` as a quoted string literal that parses back to exactly `value`, or /// `None` when no literal can: the tokenizer reads any `${vars.` inside quotes /// as a variable placeholder and has no escape for it. -#[doc(hidden)] -pub fn quote_literal(value: &str) -> Option { +pub(crate) fn quote_literal(value: &str) -> Option { (!value.contains(VAR_PLACEHOLDER)).then(|| format!("\"{}\"", escape_str(value))) } /// True when `name` is written as a bare comparison field: one path segment /// the tokenizer reads as a field rather than a keyword or literal. -#[doc(hidden)] -pub fn is_field_name(name: &str) -> bool { +pub(crate) fn is_field_name(name: &str) -> bool { let mut chars = name.chars(); chars .next() @@ -813,8 +808,7 @@ enum Token { } /// True for a syntactically valid `${vars.NAME}` variable name. -#[doc(hidden)] -pub fn is_valid_var_name(name: &str) -> bool { +pub(crate) fn is_valid_var_name(name: &str) -> bool { !name.is_empty() && name .chars() @@ -1277,8 +1271,7 @@ fn parse_filter(raw: &str) -> Result { /// Parse a filter expression, rendering any error to a caret-annotated string. /// The crate-internal entry point used by the serde impl (and tests). -#[doc(hidden)] -pub fn parse(raw: &str) -> Result { +pub(crate) fn parse(raw: &str) -> Result { // Reject before tokenization or diagnostic rendering copies the input. if raw.len() > MAX_FILTER_BYTES { return Err(format!( diff --git a/crates/submilli-blueprint/src/lib.rs b/crates/submilli-blueprint/src/lib.rs index 700f3636b..8343ef5c7 100644 --- a/crates/submilli-blueprint/src/lib.rs +++ b/crates/submilli-blueprint/src/lib.rs @@ -6,6 +6,7 @@ pub mod diff; mod edit; mod embedding; mod endpoint; +mod filter; mod git; mod llm; mod locate; @@ -25,7 +26,8 @@ use serde::ser::SerializeMap; use serde::{Deserialize, Serialize, Serializer, de}; pub use auth_proxy::{ - DeclaredSecrets, SourceSecretResolver, interpolate, resolve_injections, verify_secrets, + AuthError, AuthProxyRule, AuthSpec, BasicAuth, Injections, SecretResolver, interpolate, + resolve_injections, secret_refs, verify_secrets, }; pub use diag::{Fault, PathSeg, YamlPath}; pub use edit::{Draft, DraftCall, DraftError, draft_allow}; @@ -33,21 +35,21 @@ pub use embedding::{ EmbeddingConfig, EmbeddingModelDecl, EmbeddingProviderDecl, EmbeddingProviderType, limits as embedding_limits, }; +pub use filter::{ + ComparisonFailure, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, VarBindings, +}; pub use git::{GitConfig, GitIdentity}; pub use llm::{LlmConfig, LlmModelDecl, LlmProviderDecl}; pub use locate::{Citation, RuleLocation, locate_key, locate_rule}; pub use mcp::{McpAuth, McpServer}; +pub use permissions::{ + Action, DefaultAction, NearMiss, PermissionRule, Resolution, ResolutionCause, RuleRef, +}; pub use secrets::{ HarnessSecret, HarnessSecretBindings, HarnessSecretError, SecretSource, required_harness_secrets, resolve_harness_secrets, }; -use submilli_policy::serde_support::Reject; -pub use submilli_policy::{ - Action, AuthError, AuthProxyPolicy, AuthProxyRule, AuthSpec, BasicAuth, ComparisonFailure, - DefaultAction, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, Injections, NearMiss, - PermissionRule, Policy, Resolution, ResolutionCause, RuleRef, VarBindings, VariableDecl, - VariableError, resolve_variables, secret_refs, -}; +pub use variables::{VariableDecl, VariableError, resolve_variables}; #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] #[serde(deny_unknown_fields)] @@ -183,7 +185,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> (Action, Option) { - submilli_policy::resolve_with_rule( + permissions::resolve_with_rule( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -204,7 +206,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> Resolution { - submilli_policy::explain( + permissions::explain( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -225,7 +227,7 @@ impl Blueprint { context: &serde_json::Value, vars: &VarBindings, ) -> Action { - submilli_policy::resolve( + permissions::resolve( &self.permissions, self.default_action.unwrap_or_default(), caller, @@ -234,23 +236,6 @@ impl Blueprint { vars, ) } - - /// The `permissions:` block and `default:` as a format-neutral [`Policy`]. - pub fn policy(&self) -> Policy { - Policy { - rules: self.permissions.clone(), - default: self.default_action.unwrap_or_default(), - } - } - - /// The `auth_proxy:` block and the blueprint-wide cleartext opt-in as a - /// format-neutral [`AuthProxyPolicy`]. - pub fn auth_proxy_policy(&self) -> AuthProxyPolicy { - AuthProxyPolicy { - allow_insecure_http: self.allow_insecure_http, - rules: self.auth_proxy.clone(), - } - } } fn default_idle_timeout() -> Duration { @@ -728,6 +713,88 @@ impl<'de, S: de::DeserializeSeed<'de>> de::DeserializeSeed<'de> for Guarded { } } +/// A map value whose deserialization always fails, standing in for a value of +/// type `T` so it can replace any field's seed. +/// +/// Raising the error from *inside* the value is what anchors the diagnostic at +/// that key: an error returned from [`VfsVisitor::visit_map`] itself carries +/// only the `vfs:` path, which is too coarse for an editor to squiggle the +/// offending line. Failing from within the visitor rather than after consuming +/// the node also keeps the YAML parser's mark on the value, so the reported +/// line is the offending one and not the first line of the block. +struct Reject(String, PhantomData); + +impl Reject { + fn new(message: impl Into) -> Self { + Reject(message.into(), PhantomData) + } + + fn fail(self) -> Result { + Err(de::Error::custom(self.0)) + } +} + +impl<'de, T> de::DeserializeSeed<'de> for Reject { + type Value = T; + + fn deserialize(self, deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + deserializer.deserialize_any(self) + } +} + +// Every shape of value gets the same message; the default `Visitor` methods +// would replace it with serde's own `invalid type` wording. +impl<'de, T> de::Visitor<'de> for Reject { + type Value = T; + + fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(&self.0) + } + + fn visit_bool(self, _: bool) -> Result { + self.fail() + } + + fn visit_i64(self, _: i64) -> Result { + self.fail() + } + + fn visit_u64(self, _: u64) -> Result { + self.fail() + } + + fn visit_f64(self, _: f64) -> Result { + self.fail() + } + + fn visit_str(self, _: &str) -> Result { + self.fail() + } + + fn visit_bytes(self, _: &[u8]) -> Result { + self.fail() + } + + fn visit_unit(self) -> Result { + self.fail() + } + + fn visit_seq>(self, _: A) -> Result { + self.fail() + } + + fn visit_map>(self, _: A) -> Result { + self.fail() + } + + fn visit_enum>(self, _: A) -> Result { + self.fail() + } +} + /// Reads `volume:` as a non-empty string, anchoring both the wrong-type and the /// empty-name diagnostic at the `volume` key. Goes through `deserialize_any` so /// a non-string scalar is refused rather than silently read as its YAML text: diff --git a/crates/submilli-blueprint/src/maps.rs b/crates/submilli-blueprint/src/maps.rs index 0d6cbaee9..2c7207265 100644 --- a/crates/submilli-blueprint/src/maps.rs +++ b/crates/submilli-blueprint/src/maps.rs @@ -1,3 +1,39 @@ -//! Name-keyed blueprint maps reject a repeated key instead of keeping the last. +use std::collections::BTreeMap; +use std::fmt; +use std::marker::PhantomData; -pub(crate) use submilli_policy::serde_support::unique_map as deserialize; +use serde::{Deserialize, Deserializer, de}; + +/// Name-keyed blueprint maps must not silently replace an earlier declaration. +pub(crate) fn deserialize<'de, D, V>(deserializer: D) -> Result, D::Error> +where + D: Deserializer<'de>, + V: Deserialize<'de>, +{ + deserializer.deserialize_map(UniqueNames(PhantomData)) +} + +struct UniqueNames(PhantomData); + +impl<'de, V: Deserialize<'de>> de::Visitor<'de> for UniqueNames { + type Value = BTreeMap; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a map with unique names") + } + + fn visit_map>(self, mut map: A) -> Result { + let mut names = BTreeMap::new(); + while let Some(name) = map.next_key::()? { + if names.contains_key(&name) { + map.next_value_seed(crate::Reject::::new(format!( + "duplicate key `{name}`: remove or rename the repeated declaration" + )))?; + continue; + } + let value = map.next_value()?; + names.insert(name, value); + } + Ok(names) + } +} diff --git a/crates/submilli-blueprint/src/mcp.rs b/crates/submilli-blueprint/src/mcp.rs index 7d3dd0f5e..7eb5d4fe0 100644 --- a/crates/submilli-blueprint/src/mcp.rs +++ b/crates/submilli-blueprint/src/mcp.rs @@ -13,8 +13,8 @@ use std::collections::BTreeMap; use serde::{Deserialize, Serialize}; +use crate::auth_proxy::secret_refs; use crate::{Blueprint, BlueprintError, Fault, yaml_path}; -use submilli_policy::secret_refs; const CAPABILITY_PREFIX: &str = "mcp."; const DEFAULT_TRANSPORT: &str = "streamable_http"; diff --git a/crates/submilli-blueprint/src/permissions.rs b/crates/submilli-blueprint/src/permissions.rs index 0c5bc239b..e6a1f15b2 100644 --- a/crates/submilli-blueprint/src/permissions.rs +++ b/crates/submilli-blueprint/src/permissions.rs @@ -1,13 +1,70 @@ -//! The blueprint `permissions:` block. The rules and their evaluation live in -//! `submilli-policy`; this checks what serde cannot, with the YAML path of the -//! offending key. +//! The blueprint `permissions:` block — the per-caller capability rules the +//! semantic-security engine evaluates. Keyed by caller identifier (`main` for +//! the user script, package name for library code), each caller maps to an +//! ordered rule list walked top-to-bottom, first-match-wins. A caller absent +//! from the map — or a caller whose rules all miss — falls through to the +//! top-level `default`. +//! +//! Each rule's optional `filter` is a [`FilterExpr`] from [`crate::filter`], +//! parsed at registration time so a malformed filter fails when the blueprint is +//! added rather than at the first `check()`. use std::collections::BTreeMap; -use submilli_policy::PermissionRule; +use serde::{Deserialize, Serialize}; +use crate::filter::{ComparisonFailure, FilterExpr, VarBindings}; use crate::{BlueprintError, Fault, yaml_path}; +/// Fall-through action when no rule matches. Absent in the blueprint, it +/// defaults to `Deny` (deny-by-default): a policy-free blueprint denies every +/// capability. `allow` flips the posture to allow-by-default — every capability +/// is permitted unless a rule denies it — for trusted deployments that prefer a +/// blocklist over an allowlist. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum DefaultAction { + #[default] + Deny, + Allow, + AskHuman, +} + +/// The action a matched rule (or the fall-through default) resolves to. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] +#[serde(rename_all = "kebab-case")] +pub enum Action { + Allow, + Deny, + AskHuman, +} + +impl From for Action { + fn from(d: DefaultAction) -> Self { + match d { + DefaultAction::Deny => Action::Deny, + DefaultAction::Allow => Action::Allow, + DefaultAction::AskHuman => Action::AskHuman, + } + } +} + +/// One capability rule. The capability name is matched verbatim (no wildcards); +/// flexibility lives in the optional `filter`. +#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct PermissionRule { + /// Label decisions cite this rule by. Unique within a caller block + /// (`blueprint lint` enforces it); the rule's position identifies it + /// otherwise. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub name: Option, + pub capability: String, + #[serde(default, skip_serializing_if = "Option::is_none")] + pub filter: Option, + pub action: Action, +} + /// Structural checks beyond what serde already enforces (malformed filters are /// rejected at deserialize time); this catches the empty caller / capability /// cases serde can't express. @@ -39,10 +96,412 @@ pub(crate) fn validate( Ok(()) } +/// Walk the rules for `caller` and return the resolved action. No caller block, +/// or no rule matching `(capability, ctx)`, falls through to `default`. +pub(crate) fn resolve( + permissions: &BTreeMap>, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> Action { + resolve_with_rule(permissions, default_action, caller, capability, ctx, vars).0 +} + +pub(crate) fn resolve_with_rule( + permissions: &BTreeMap>, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> (Action, Option) { + if let Some(rules) = permissions.get(caller) { + for (index, rule) in rules.iter().enumerate() { + if rule.capability == capability + && rule + .filter + .as_ref() + .is_none_or(|f| f.matches_with(ctx, vars)) + { + return (rule.action, Some(index)); + } + } + } + (default_action.into(), None) +} + +/// A resolved decision with the reasoning behind it. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct Resolution { + /// Identical to what [`resolve`] returns for the same inputs. + pub action: Action, + pub cause: ResolutionCause, + /// Rules for the capability, ahead of the deciding rule (or all of them + /// when the default decided), whose filters rejected the call. + pub near_misses: Vec, +} + +#[derive(Debug, Clone, PartialEq, Serialize)] +#[serde(rename_all = "kebab-case", tag = "kind")] +pub enum ResolutionCause { + Rule(RuleRef), + /// No rule matched. `caller_block` is whether the caller has any rules. + Default { + caller_block: bool, + }, +} + +/// A rule located by caller block and zero-based position, with its name when +/// it has one. +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct RuleRef { + pub caller: String, + pub index: usize, + pub name: Option, +} + +/// A rule that named the right capability but whose filter rejected the call. +#[derive(Debug, Clone, PartialEq, Serialize)] +pub struct NearMiss { + pub rule: RuleRef, + /// The rule's whole filter, from its `Display` impl. + pub filter: String, + pub failures: Vec, +} + +pub(crate) fn explain( + permissions: &BTreeMap>, + default_action: DefaultAction, + caller: &str, + capability: &str, + ctx: &serde_json::Value, + vars: &VarBindings, +) -> Resolution { + let (action, matched) = + resolve_with_rule(permissions, default_action, caller, capability, ctx, vars); + let rules = permissions.get(caller); + let rule_ref = |index: usize, rule: &PermissionRule| RuleRef { + caller: caller.to_string(), + index, + name: rule.name.clone(), + }; + let cause = match matched.and_then(|index| Some((index, rules?.get(index)?))) { + Some((index, rule)) => ResolutionCause::Rule(rule_ref(index, rule)), + None => ResolutionCause::Default { + caller_block: rules.is_some(), + }, + }; + let walked = matched.unwrap_or(usize::MAX); + let near_misses = rules + .into_iter() + .flatten() + .enumerate() + .take_while(|(index, _)| *index < walked) + .filter(|(_, rule)| rule.capability == capability) + .filter_map(|(index, rule)| { + let filter = rule.filter.as_ref()?; + let evaluation = filter.explain_with(ctx, vars); + (!evaluation.matched).then(|| NearMiss { + rule: rule_ref(index, rule), + filter: filter.to_string(), + failures: evaluation.failures, + }) + }) + .collect(); + Resolution { + action, + cause, + near_misses, + } +} + #[cfg(test)] mod tests { use super::*; - use submilli_policy::Action; + use serde_json::json; + + fn filter(s: &str) -> FilterExpr { + crate::filter::parse(s).expect("valid filter") + } + + #[test] + fn resolve_first_match_wins() { + let mut perms = BTreeMap::new(); + perms.insert( + "main".to_string(), + vec![ + PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: Some(filter("amount < 500")), + action: Action::Allow, + }, + PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: None, + action: Action::AskHuman, + }, + ], + ); + let allow = resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/charge", + &json!({ "amount": 100 }), + &VarBindings::new(), + ); + assert_eq!(allow, Action::Allow); + let ask = resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/charge", + &json!({ "amount": 900 }), + &VarBindings::new(), + ); + assert_eq!(ask, Action::AskHuman); + } + + #[test] + fn resolve_falls_through_to_default() { + let perms = BTreeMap::new(); + // Caller absent entirely. + assert_eq!( + resolve( + &perms, + DefaultAction::Deny, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::Deny + ); + assert_eq!( + resolve( + &perms, + DefaultAction::AskHuman, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::AskHuman + ); + assert_eq!( + resolve( + &perms, + DefaultAction::Allow, + "main", + "x", + &json!({}), + &VarBindings::new() + ), + Action::Allow + ); + } + + #[test] + fn resolve_capability_is_exact() { + let mut perms = BTreeMap::new(); + perms.insert( + "main".to_string(), + vec![PermissionRule { + name: None, + capability: "stripe.com/charge".into(), + filter: None, + action: Action::Allow, + }], + ); + // No wildcard: a sibling capability falls through to default. + assert_eq!( + resolve( + &perms, + DefaultAction::Deny, + "main", + "stripe.com/refund", + &json!({}), + &VarBindings::new() + ), + Action::Deny + ); + } + + fn rule( + name: Option<&str>, + capability: &str, + f: Option<&str>, + action: Action, + ) -> PermissionRule { + PermissionRule { + name: name.map(str::to_string), + capability: capability.into(), + filter: f.map(filter), + action, + } + } + + fn vars(pairs: &[(&str, &str)]) -> VarBindings { + pairs + .iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect() + } + + fn explain_main( + rules: Vec, + default: DefaultAction, + capability: &str, + ctx: serde_json::Value, + bindings: &VarBindings, + ) -> Resolution { + let perms = BTreeMap::from([("main".to_string(), rules)]); + let resolution = explain(&perms, default, "main", capability, &ctx, bindings); + // The explanation never disagrees with enforcement. + assert_eq!( + resolution.action, + resolve(&perms, default, "main", capability, &ctx, bindings) + ); + resolution + } + + #[test] + fn explain_filter_miss_is_a_near_miss_under_default() { + let resolution = explain_main( + vec![rule( + Some("own-customer"), + "acme.com/charges.list", + Some("customerId == ${vars.customerId}"), + Action::Allow, + )], + DefaultAction::Deny, + "acme.com/charges.list", + json!({ "customerId": "cus_initech" }), + &vars(&[("customerId", "cus_northwind")]), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Default { caller_block: true } + ); + let [miss] = resolution.near_misses.as_slice() else { + panic!("expected one near miss: {resolution:?}"); + }; + assert_eq!(miss.rule.index, 0); + assert_eq!(miss.rule.name.as_deref(), Some("own-customer")); + assert_eq!(miss.filter, "customerId == ${vars.customerId}"); + let [failure] = miss.failures.as_slice() else { + panic!("expected one failure: {miss:?}"); + }; + assert_eq!(failure.comparison, "customerId == ${vars.customerId}"); + assert_eq!(failure.actual, Some(json!("cus_initech"))); + assert_eq!(failure.expected.as_deref(), Some("cus_northwind")); + } + + #[test] + fn explain_second_rule_match_cites_index_and_name() { + let resolution = explain_main( + vec![ + rule( + None, + "stripe.com/charge", + Some("amount < 500"), + Action::Allow, + ), + rule(Some("big-charges"), "stripe.com/charge", None, Action::Deny), + ], + DefaultAction::Allow, + "stripe.com/charge", + json!({ "amount": 900 }), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Rule(RuleRef { + caller: "main".into(), + index: 1, + name: Some("big-charges".into()), + }) + ); + // The earlier rule that rejected the call is still reported. + assert_eq!(resolution.near_misses.len(), 1); + assert_eq!(resolution.near_misses[0].rule.index, 0); + assert_eq!(resolution.near_misses[0].rule.name, None); + } + + #[test] + fn explain_without_caller_block_reports_it() { + let perms = BTreeMap::new(); + let resolution = explain( + &perms, + DefaultAction::Deny, + "main", + "x", + &json!({}), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::Deny); + assert_eq!( + resolution.cause, + ResolutionCause::Default { + caller_block: false + } + ); + assert!(resolution.near_misses.is_empty()); + } + + #[test] + fn explain_ask_human_stays_distinct_and_names_the_rule() { + let resolution = explain_main( + vec![rule( + Some("review-refunds"), + "stripe.com/refund", + None, + Action::AskHuman, + )], + DefaultAction::Deny, + "stripe.com/refund", + json!({}), + &VarBindings::new(), + ); + assert_eq!(resolution.action, Action::AskHuman); + let ResolutionCause::Rule(rule) = &resolution.cause else { + panic!("expected a rule cause: {resolution:?}"); + }; + assert_eq!(rule.name.as_deref(), Some("review-refunds")); + } + + #[test] + fn explain_unbound_variable_failure() { + let resolution = explain_main( + vec![rule(None, "x", Some("id == ${vars.x}"), Action::Allow)], + DefaultAction::Deny, + "x", + json!({ "id": "a" }), + &VarBindings::new(), + ); + assert_eq!( + resolution.near_misses[0].failures[0].reason, + crate::filter::FailureReason::VariableNotBound("x".into()) + ); + } + + #[test] + fn explain_ignores_other_capabilities() { + let resolution = explain_main( + vec![rule(None, "a", Some("n == 1"), Action::Allow)], + DefaultAction::Deny, + "b", + json!({ "n": 2 }), + &VarBindings::new(), + ); + assert!(resolution.near_misses.is_empty()); + } #[test] fn rule_name_is_optional_and_unknown_fields_still_rejected() { @@ -66,12 +525,7 @@ mod tests { fn empty_rule_name_is_invalid() { let perms = BTreeMap::from([( "main".to_string(), - vec![PermissionRule { - name: Some(String::new()), - capability: "a".into(), - filter: None, - action: Action::Allow, - }], + vec![rule(Some(""), "a", None, Action::Allow)], )]); assert!(validate(&perms).is_err()); } diff --git a/crates/submilli-blueprint/src/variables.rs b/crates/submilli-blueprint/src/variables.rs index 77a4b63a6..435f7573d 100644 --- a/crates/submilli-blueprint/src/variables.rs +++ b/crates/submilli-blueprint/src/variables.rs @@ -9,8 +9,56 @@ //! REST `/v1/execute` path and the MCP `initialize` path run before a session is //! allowed to open. +use std::collections::BTreeMap; +use std::fmt; + +use serde::{Deserialize, Serialize}; + use crate::{Blueprint, BlueprintError, Fault, yaml_path}; +/// One declared variable. `required` and `default` are mutually exclusive: a +/// required variable with a default is contradictory (rejected at parse). +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct VariableDecl { + /// The session is rejected at init if this variable is missing or empty. + #[serde(default, skip_serializing_if = "is_false")] + pub required: bool, + /// Value bound when the caller supplies none. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub default: Option, +} + +fn is_false(b: &bool) -> bool { + !*b +} + +/// A failure binding caller-supplied variables against the blueprint's +/// declarations, surfaced at session init (REST → 400, MCP → failed +/// `initialize`). +#[derive(Debug, Clone, PartialEq, Eq)] +pub enum VariableError { + /// A `required` variable was not supplied (or supplied empty). + MissingRequired(String), + /// A supplied variable name is not declared in the blueprint. + Unknown(String), +} + +impl fmt::Display for VariableError { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + VariableError::MissingRequired(name) => { + write!(f, "required variable '{name}' was not supplied") + } + VariableError::Unknown(name) => { + write!(f, "variable '{name}' is not declared in the blueprint") + } + } + } +} + +impl std::error::Error for VariableError {} + /// Parse-time structural checks: `required`+`default` is contradictory, and /// every `${vars.NAME}` a permission filter references must name a declared /// variable. Declared-but-unused variables are allowed (no warning channel; @@ -45,12 +93,43 @@ pub(crate) fn validate_variables(blueprint: &Blueprint) -> Result<(), BlueprintE Ok(()) } +/// Bind caller-supplied values against the declarations: fill defaults, reject a +/// missing/empty `required` variable, reject any supplied name that isn't +/// declared. Returns the resolved bindings filter evaluation reads. An optional +/// variable with no value and no default is simply omitted — an absent +/// `${vars.NAME}` is a non-match at eval, never a trap. +pub fn resolve_variables( + decls: &BTreeMap, + supplied: &BTreeMap, +) -> Result, VariableError> { + for name in supplied.keys() { + if !decls.contains_key(name) { + return Err(VariableError::Unknown(name.clone())); + } + } + let mut resolved = BTreeMap::new(); + for (name, decl) in decls { + match supplied.get(name) { + Some(value) if !value.is_empty() => { + resolved.insert(name.clone(), value.clone()); + } + _ => { + if decl.required { + return Err(VariableError::MissingRequired(name.clone())); + } + if let Some(default) = &decl.default { + resolved.insert(name.clone(), default.clone()); + } + } + } + } + Ok(resolved) +} + #[cfg(test)] mod tests { - use std::collections::BTreeMap; - use super::*; - use crate::{VariableDecl, VariableError, parse, resolve_variables}; + use crate::parse; fn decls(yaml: &str) -> BTreeMap { parse(yaml).expect("valid blueprint").variables diff --git a/crates/submilli-policy/Cargo.toml b/crates/submilli-policy/Cargo.toml deleted file mode 100644 index 33c3e31fb..000000000 --- a/crates/submilli-policy/Cargo.toml +++ /dev/null @@ -1,34 +0,0 @@ -[package] -name = "submilli-policy" -description = "The Submilli policy engine: permission rules and their filter language, session variables, and auth-proxy injection" -version.workspace = true -edition.workspace = true -license.workspace = true -repository.workspace = true -readme = "README.md" -keywords = ["submilli", "policy", "permissions", "agents"] -categories = ["config"] -publish = true - -[lints] -workspace = true - -[lib] -path = "src/lib.rs" - -[dependencies] -serde = { workspace = true, features = ["derive"] } -serde_json = { workspace = true } -regex = { workspace = true } -async-trait = { workspace = true } -base64 = { workspace = true } -submilli-engine = { version = "0.3.0", path = "../interpreter", optional = true } -url = { workspace = true, optional = true } - -[features] -# Adapters from the policy types to the engine's host-service traits. -engine = ["dep:submilli-engine", "dep:url"] - -[dev-dependencies] -submilli-engine = { path = "../interpreter" } -tokio = { workspace = true, features = ["rt", "macros"] } diff --git a/crates/submilli-policy/README.md b/crates/submilli-policy/README.md deleted file mode 100644 index f1015729a..000000000 --- a/crates/submilli-policy/README.md +++ /dev/null @@ -1,15 +0,0 @@ -# submilli-policy - -The policy engine of [Submilli](https://github.com/submilli/submilli-runtime): -per-caller permission rules and their filter language, session variables, and -auth-proxy injection of secrets into outbound HTTP. - -The types are format-neutral. A Submilli blueprint file is one way to write a -policy; an embedder that keeps policy elsewhere builds a `Policy` and an -`AuthProxyPolicy` from its own format and evaluates them the same way. - -With the `engine` feature, `submilli_policy::host` adapts them to -[`submilli-engine`](https://crates.io/crates/submilli-engine)'s host-service -traits: `PolicyCheck`, `PolicyAuthProxy` and `PolicySecretProvider`. - -Licensed under Apache-2.0. diff --git a/crates/submilli-policy/src/auth_proxy.rs b/crates/submilli-policy/src/auth_proxy.rs deleted file mode 100644 index d56b3c723..000000000 --- a/crates/submilli-policy/src/auth_proxy.rs +++ /dev/null @@ -1,271 +0,0 @@ -//! Auth-proxy rules: host-keyed rules that inject auth headers and query -//! parameters into outbound HTTP, with `${secrets.X}` resolved through a -//! [`SecretResolver`]. The program never sees the resolved values. -//! -//! This module computes what to inject; the embedder supplies the resolver and -//! adapts the result to the runtime's `AuthProxy` trait. - -use std::collections::BTreeMap; -use std::fmt; - -use base64::{Engine as _, engine::general_purpose::STANDARD}; -use serde::{Deserialize, Serialize}; - -const PLACEHOLDER_PREFIX: &str = "${secrets."; - -/// Every auth-proxy rule in force, and whether cleartext HTTP may be used at -/// all. -#[derive(Debug, Clone, Default, PartialEq, Eq)] -pub struct AuthProxyPolicy { - /// Permit cleartext requests; a rule must opt in separately to inject into - /// one. - pub allow_insecure_http: bool, - pub rules: Vec, -} - -/// One host-keyed injection rule. v1 matches `host` exactly. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct AuthProxyRule { - pub host: String, - /// Also requires the policy-wide opt-in to permit cleartext requests. - #[serde(default, skip_serializing_if = "std::ops::Not::not")] - pub allow_insecure_http: bool, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub auth: Option, - #[serde( - default, - skip_serializing_if = "BTreeMap::is_empty", - deserialize_with = "crate::serde_support::unique_map" - )] - pub headers: BTreeMap, - #[serde( - default, - skip_serializing_if = "BTreeMap::is_empty", - deserialize_with = "crate::serde_support::unique_map" - )] - pub query: BTreeMap, -} - -/// A first-class auth method, lowered into an `Authorization` header at resolve -/// time. Exactly one of `bearer`/`basic` is set (the format that reads rules -/// enforces it). `bearer` / basic `password` name declared secrets; basic -/// `username` is a literal. Basic auth can't be expressed as an -/// interpolation-only header value — its `base64(user:pass)` is computed *after* -/// the password secret resolves. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct AuthSpec { - #[serde(default, skip_serializing_if = "Option::is_none")] - pub bearer: Option, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub basic: Option, -} - -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct BasicAuth { - pub username: String, - pub password: String, -} - -/// Resolves a secret, by name, to its value. Implemented by the embedder, which -/// knows which names are declared and where each value comes from: a name it -/// does not declare is [`AuthError::UndeclaredSecret`]. Async so a store can be -/// awaited without blocking the executor. -#[async_trait::async_trait] -pub trait SecretResolver: Send + Sync { - async fn resolve(&self, name: &str) -> Result; -} - -/// What an auth-proxy rule contributes to a request. Header/query *names* are -/// taken verbatim; values have their `${secrets.X}` placeholders resolved. -#[derive(Debug, Clone, PartialEq, Eq, Default)] -pub struct Injections { - pub headers: Vec<(String, String)>, - pub query: Vec<(String, String)>, -} - -/// Runtime auth-proxy failure. Maps onto the runtime's `AuthProxyError`. -#[derive(Debug)] -pub enum AuthError { - /// `${secrets.X}` referenced an undeclared name. - UndeclaredSecret(String), - /// Secret declared but its source produced no value. - MissingSecret(String), - Other(String), -} - -impl fmt::Display for AuthError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - AuthError::UndeclaredSecret(name) => write!(f, "undeclared secret '{name}'"), - AuthError::MissingSecret(name) => write!(f, "missing secret '{name}'"), - AuthError::Other(msg) => f.write_str(msg), - } - } -} - -impl std::error::Error for AuthError {} - -/// The `${secrets.NAME}` names referenced by a value, in order. -pub fn secret_refs(value: &str) -> Vec<&str> { - let mut names = Vec::new(); - let mut rest = value; - while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { - let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; - match after.find('}') { - Some(end) => { - names.push(&after[..end]); - rest = &after[end + 1..]; - } - None => break, - } - } - names -} - -/// The first rule whose `host` matches exactly, with `${secrets.X}` resolved. -/// `Ok(None)` when no rule matches. -pub async fn resolve_injections( - rules: &[AuthProxyRule], - host: &str, - resolver: &dyn SecretResolver, -) -> Result, AuthError> { - let Some(rule) = rules.iter().find(|r| r.host == host) else { - return Ok(None); - }; - let mut headers = interpolate_pairs(&rule.headers, resolver).await?; - if let Some(auth) = &rule.auth { - headers.push(( - "Authorization".to_string(), - resolve_authorization(auth, resolver).await?, - )); - } - Ok(Some(Injections { - headers, - query: interpolate_pairs(&rule.query, resolver).await?, - })) -} - -/// The `Authorization` header value for an `auth:` method: `Bearer ` or -/// `Basic `. `bearer`/`password` name declared secrets and -/// are resolved directly (not `${secrets.X}` interpolation). -async fn resolve_authorization( - auth: &AuthSpec, - resolver: &dyn SecretResolver, -) -> Result { - if let Some(secret) = &auth.bearer { - return Ok(format!("Bearer {}", resolver.resolve(secret).await?)); - } - if let Some(basic) = &auth.basic { - let password = resolver.resolve(&basic.password).await?; - let token = STANDARD.encode(format!("{}:{password}", basic.username)); - return Ok(format!("Basic {token}")); - } - Err(AuthError::Other( - "auth_proxy rule has an empty `auth:` block".into(), - )) -} - -async fn interpolate_pairs( - pairs: &BTreeMap, - resolver: &dyn SecretResolver, -) -> Result, AuthError> { - let mut out = Vec::with_capacity(pairs.len()); - for (name, value) in pairs { - out.push((name.clone(), interpolate(value, resolver).await?)); - } - Ok(out) -} - -/// Replace every `${secrets.NAME}` in `value` with its resolved secret. Public so -/// other settings that interpolate secrets can reuse the exact placeholder -/// semantics auth-proxy rules use. -pub async fn interpolate(value: &str, resolver: &dyn SecretResolver) -> Result { - let mut out = String::new(); - let mut rest = value; - while let Some(start) = rest.find(PLACEHOLDER_PREFIX) { - out.push_str(&rest[..start]); - let after = &rest[start + PLACEHOLDER_PREFIX.len()..]; - let end = after.find('}').ok_or_else(|| { - AuthError::Other(format!( - "unterminated '{PLACEHOLDER_PREFIX}...}}' in '{value}'" - )) - })?; - out.push_str(&resolver.resolve(&after[..end]).await?); - rest = &after[end + 1..]; - } - out.push_str(rest); - Ok(out) -} - -#[cfg(test)] -mod tests { - use super::*; - - /// Knows `K` and `P`, resolving each to `"-value"`. - struct Stub; - - #[async_trait::async_trait] - impl SecretResolver for Stub { - async fn resolve(&self, name: &str) -> Result { - match name { - "K" | "P" => Ok(format!("{name}-value")), - _ => Err(AuthError::UndeclaredSecret(name.to_string())), - } - } - } - - fn rule(host: &str) -> AuthProxyRule { - AuthProxyRule { - host: host.to_string(), - allow_insecure_http: false, - auth: None, - headers: BTreeMap::new(), - query: BTreeMap::new(), - } - } - - #[tokio::test] - async fn rules_resolve_by_name_without_a_blueprint() { - let rules = vec![ - AuthProxyRule { - headers: BTreeMap::from([("X-Key".to_string(), "k=${secrets.K}".to_string())]), - auth: Some(AuthSpec { - bearer: None, - basic: Some(BasicAuth { - username: "alice".to_string(), - password: "P".to_string(), - }), - }), - ..rule("h") - }, - rule("other"), - ]; - let injections = resolve_injections(&rules, "h", &Stub) - .await - .expect("resolves") - .expect("rule matches"); - let basic = STANDARD.encode("alice:P-value"); - assert_eq!( - injections.headers, - [ - ("X-Key".to_string(), "k=K-value".to_string()), - ("Authorization".to_string(), format!("Basic {basic}")), - ] - ); - assert!( - resolve_injections(&rules, "none", &Stub) - .await - .expect("ok") - .is_none() - ); - } - - #[tokio::test] - async fn an_undeclared_name_surfaces_from_the_resolver() { - let err = interpolate("${secrets.NOPE}", &Stub).await.unwrap_err(); - assert!(matches!(err, AuthError::UndeclaredSecret(name) if name == "NOPE")); - } -} diff --git a/crates/submilli-policy/src/host.rs b/crates/submilli-policy/src/host.rs deleted file mode 100644 index 6f2b23e5c..000000000 --- a/crates/submilli-policy/src/host.rs +++ /dev/null @@ -1,468 +0,0 @@ -//! Adapters from a [`Policy`] and an [`AuthProxyPolicy`] to the engine's -//! host-service traits ([`SecurityCheck`], [`AuthProxy`], [`SecretProvider`]), -//! for an embedder to install on a store. Behind the `engine` feature, so the -//! policy types themselves stay free of the engine. - -use std::borrow::Cow; -use std::collections::BTreeMap; -use std::sync::Arc; - -use async_trait::async_trait; -use submilli_engine::runtime::{ - AuthProxy, AuthProxyError, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, - FailureReasonRecord, FailureRecord, HttpRequest, NearMissRecord, RuleCitation, SecretProvider, - SecurityCheck, -}; -use submilli_engine::stdlib::http::HttpTransportPolicy; -use url::Url; - -use crate::{ - Action, AuthError, AuthProxyPolicy, AuthProxyRule, ComparisonFailure, FailureReason, - Injections, NearMiss, Policy, Resolution, ResolutionCause, RuleRef, SecretResolver, - VarBindings, resolve_injections, -}; - -/// The package name auth-proxy injection is scoped to. Matches the name the runtime gives a -/// user script's module, which is what it reads off the running wasm frame to identify a -/// caller. -const MAIN_PACKAGE: &str = "main"; - -// ---- SecurityCheck ------------------------------------------------------- - -/// [`Policy`]-driven [`SecurityCheck`]: evaluates the permission rules for each -/// capability check. -/// -/// Deny-by-default: a capability is allowed only when a rule says so, and a -/// policy with no rules and a `Deny` default denies every capability. An -/// `Allow` default inverts this to allow-by-default. `ask-human` -/// is deferred (no suspend/resume yet), so it resolves to `Deny` with a reason -/// that says so. -/// -/// Filesystem rules see absolute guest paths with `.` and `..` collapsed using -/// the same lexical resolver as VFS I/O. This also applies to both endpoints of -/// copy/move and the destination of HTTP downloads. It does not resolve symlinks. -pub struct PolicyCheck { - policy: Arc, - /// Caller-supplied `${vars.NAME}` bindings for this session, resolved at - /// session init. Empty for callers that bind no variables. - variables: Arc, -} - -impl PolicyCheck { - pub fn new(policy: Arc) -> Self { - Self::with_variables(policy, Arc::new(BTreeMap::new())) - } - - /// As [`Self::new`], with the session's resolved variable bindings threaded - /// into every `${vars.NAME}` filter operand. - pub fn with_variables(policy: Arc, variables: Arc) -> Self { - PolicyCheck { policy, variables } - } -} - -impl SecurityCheck for PolicyCheck { - fn audit_context<'a>( - &self, - capability: &str, - context: &'a serde_json::Value, - cwd: &str, - ) -> Cow<'a, serde_json::Value> { - filesystem_policy_context(capability, context, cwd).unwrap_or(Cow::Borrowed(context)) - } - - fn check(&self, caller: &str, capability: &str, context: &serde_json::Value) -> CheckOutcome { - self.check_with_cwd(caller, capability, context, "/") - } - - fn explain( - &self, - caller: &str, - capability: &str, - context: &serde_json::Value, - cwd: &str, - ) -> Option { - let context = match filesystem_policy_context(capability, context, cwd) { - Ok(context) => context, - // `check_with_cwd` refuses these before resolution: no rule can grant them. - Err(reason) => { - return Some(DecisionExplanation { - action: DecisionAction::Deny, - cause: DecisionCause::RuntimeInvariant { reason }, - near_misses: Vec::new(), - }); - } - }; - let resolution = self - .policy - .explain(caller, capability, &context, &self.variables); - Some(explanation_of(resolution)) - } - - fn check_with_cwd( - &self, - caller: &str, - capability: &str, - context: &serde_json::Value, - cwd: &str, - ) -> CheckOutcome { - let context = match filesystem_policy_context(capability, context, cwd) { - Ok(context) => context, - Err(reason) => return CheckOutcome::Deny { reason, rule: None }, - }; - let (action, rule) = - self.policy - .resolve_with_rule(caller, capability, &context, &self.variables); - match action { - Action::Allow => CheckOutcome::Allow { rule }, - Action::Deny => CheckOutcome::Deny { - rule, - reason: format!( - "policy denied {capability}{} for {caller}", - filesystem_target(capability, &context) - ), - }, - Action::AskHuman => CheckOutcome::Deny { - rule, - reason: format!( - "policy requires human approval for {capability}{} (caller {caller}); \ - ask-human is deferred and treated as deny", - filesystem_target(capability, &context) - ), - }, - } - } -} - -fn explanation_of(resolution: Resolution) -> DecisionExplanation { - DecisionExplanation { - action: match resolution.action { - Action::Allow => DecisionAction::Allow, - Action::Deny => DecisionAction::Deny, - Action::AskHuman => DecisionAction::AskHuman, - }, - cause: cause_of(resolution.cause), - near_misses: resolution - .near_misses - .into_iter() - .map(near_miss_record) - .collect(), - } -} - -fn citation(rule: RuleRef) -> RuleCitation { - RuleCitation { - caller: rule.caller, - index: rule.index, - name: rule.name, - } -} - -fn cause_of(cause: ResolutionCause) -> DecisionCause { - match cause { - ResolutionCause::Rule(rule) => DecisionCause::Rule(citation(rule)), - ResolutionCause::Default { caller_block } => DecisionCause::Default { caller_block }, - } -} - -fn near_miss_record(miss: NearMiss) -> NearMissRecord { - NearMissRecord { - rule: citation(miss.rule), - filter: miss.filter, - failures: miss.failures.into_iter().map(failure_record).collect(), - } -} - -fn failure_record(failure: ComparisonFailure) -> FailureRecord { - let reason = match failure.reason { - FailureReason::FieldMissing => FailureReasonRecord::FieldMissing, - FailureReason::VariableNotBound(name) => FailureReasonRecord::VariableNotBound(name), - FailureReason::NotSatisfied => FailureReasonRecord::NotSatisfied, - }; - FailureRecord { - comparison: failure.comparison, - actual: failure.actual, - expected: failure.expected, - reason, - negated: failure.negated, - } -} - -/// The normalized VFS paths a denial was for, so a narrowed filter can be fixed -/// from the message. The library may have probed a path on the program's -/// behalf, as `submilli:code` does for ignore files, so the program's own -/// arguments do not always name it. Empty for capabilities without VFS paths. -fn filesystem_target(capability: &str, context: &serde_json::Value) -> String { - let path = |field: &&str| context.get(*field).and_then(serde_json::Value::as_str); - match filesystem_path_fields(capability) { - [single] => path(single).map_or_else(String::new, |path| format!(" on {path}")), - [from, to] => match (path(from), path(to)) { - (Some(from), Some(to)) => format!(" from {from} to {to}"), - _ => String::new(), - }, - _ => String::new(), - } -} - -/// The context fields of a capability that hold VFS paths. -fn filesystem_path_fields(capability: &str) -> &'static [&'static str] { - match capability { - "fs.read" | "fs.write" | "fs.stat" | "fs.list" | "fs.mkdir" | "fs.remove" => &["path"], - "fs.copy" | "fs.move" => &["from", "to"], - "git.init" | "git.clone" | "git.fetch" | "git.commit" => &["path"], - "http.download" => &["vfs_path"], - _ => &[], - } -} - -/// Keep policy paths in the same guest namespace as the subsequent VFS operation. -/// Normalization is lexical and performs no I/O, so a denial cannot reveal whether -/// the target exists. URL paths and application-defined capabilities stay untouched. -fn filesystem_policy_context<'a>( - capability: &str, - context: &'a serde_json::Value, - cwd: &str, -) -> Result, String> { - let fields = filesystem_path_fields(capability); - let mut normalized_context = Cow::Borrowed(context); - for &field in fields { - let path = context - .get(field) - .and_then(serde_json::Value::as_str) - .ok_or_else(|| { - format!("invalid {capability} context: {field} must be a VFS path string") - })?; - let normalized = submilli_engine::runtime::fs::guest_normalize(cwd, path) - .map_err(|error| format!("invalid {capability} {field}: {error}"))?; - if normalized != path { - normalized_context.to_mut()[field] = serde_json::Value::String(normalized); - } - } - Ok(normalized_context) -} - -// ---- AuthProxy ----------------------------------------------------------- - -/// [`AuthProxy`] backed by an [`AuthProxyPolicy`]. Injects the matching rule's -/// headers / query params (with `${secrets.X}` resolved) into outbound -/// `submilli:http` calls made by `main`. -pub struct PolicyAuthProxy { - transport_policy: Arc, - authenticated_policy: Arc, - rules: Vec, - resolver: Arc, -} - -impl PolicyAuthProxy { - pub fn new(policy: AuthProxyPolicy, resolver: Arc) -> Self { - let transport_policy = HttpTransportPolicy { - allow_insecure_http: policy.allow_insecure_http, - auth_proxy_hosts: policy - .rules - .iter() - .map(|rule| (rule.host.clone(), rule.allow_insecure_http)) - .collect(), - same_origin_redirects: false, - }; - let authenticated_policy = Arc::new(HttpTransportPolicy { - same_origin_redirects: true, - ..transport_policy.clone() - }); - Self { - transport_policy: Arc::new(transport_policy), - authenticated_policy, - rules: policy.rules, - resolver, - } - } -} - -#[async_trait] -impl AuthProxy for PolicyAuthProxy { - async fn transform( - &self, - mut req: HttpRequest, - caller: &str, - ) -> Result { - req.transport_policy = Some(Arc::clone(&self.transport_policy)); - // Check every caller before resolving credentials, including package calls. - let url = - Url::parse(&req.url).map_err(|_| AuthProxyError::Other("invalid HTTP URL".into()))?; - self.transport_policy - .check_destination(&url) - .map_err(|error| AuthProxyError::Other(error.to_string()))?; - if caller != MAIN_PACKAGE { - return Ok(req); - } - let Some(host) = url.host_str() else { - return Ok(req); - }; - let Some(injections) = resolve_injections(&self.rules, host, self.resolver.as_ref()) - .await - .map_err(to_proxy_error)? - else { - return Ok(req); - }; - req.transport_policy = Some(Arc::clone(&self.authenticated_policy)); - apply(&mut req, injections); - Ok(req) - } -} - -/// Apply injections; the policy's value overrides any the program set itself. -fn apply(req: &mut HttpRequest, injections: Injections) { - for (name, value) in injections.headers { - let key = name.to_ascii_lowercase(); // host stores header names lowercased - req.headers.retain(|(k, _)| *k != key); - req.headers.push((key, value)); - } - if !injections.query.is_empty() - && let Ok(url) = Url::parse(&req.url) - { - req.url = with_query(&url, &injections.query); - } -} - -/// Rebuild the URL's query string: keep the program's params except those the -/// policy sets (the policy wins), then append the injected ones. -fn with_query(url: &Url, injected: &[(String, String)]) -> String { - let overridden: Vec<&str> = injected.iter().map(|(k, _)| k.as_str()).collect(); - let kept: Vec<(String, String)> = url - .query_pairs() - .filter(|(k, _)| !overridden.contains(&k.as_ref())) - .map(|(k, v)| (k.into_owned(), v.into_owned())) - .collect(); - let mut out = url.clone(); - { - let mut pairs = out.query_pairs_mut(); - pairs.clear(); - for (k, v) in &kept { - pairs.append_pair(k, v); - } - for (k, v) in injected { - pairs.append_pair(k, v); - } - } - // `query_pairs_mut().clear()` on an originally-empty query leaves a bare `?`. - if out.query() == Some("") { - out.set_query(None); - } - out.to_string() -} - -fn to_proxy_error(err: AuthError) -> AuthProxyError { - match err { - AuthError::UndeclaredSecret(name) => AuthProxyError::UndeclaredSecret(name), - AuthError::MissingSecret(name) => AuthProxyError::MissingSecret(name), - AuthError::Other(msg) => AuthProxyError::Other(msg), - } -} - -// ---- SecretProvider ------------------------------------------------------ - -/// [`SecretProvider`] for the program-visible `submilli:secrets.get`: a secret -/// the resolver does not declare, or that has no value, reads as absent. -pub struct PolicySecretProvider { - resolver: Arc, -} - -impl PolicySecretProvider { - pub fn new(resolver: Arc) -> Self { - Self { resolver } - } -} - -impl SecretProvider for PolicySecretProvider { - fn get<'a>( - &'a self, - name: &'a str, - ) -> std::pin::Pin< - Box, String>> + Send + 'a>, - > { - Box::pin(async move { - match self.resolver.resolve(name).await { - Ok(value) => Ok(Some(value)), - Err(AuthError::UndeclaredSecret(_) | AuthError::MissingSecret(_)) => Ok(None), - Err(AuthError::Other(msg)) => Err(msg), - } - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - /// An embedder that keeps policy outside a blueprint installs the same check: - /// rules it built itself, its session variables, and the guest's cwd. - #[test] - fn a_hand_built_policy_checks_normalized_paths_and_variables() { - let policy = Policy { - rules: BTreeMap::from([( - "main".to_string(), - vec![crate::PermissionRule { - name: None, - capability: "fs.read".to_string(), - filter: Some("path glob \"/${vars.user}/*\"".parse().expect("filter")), - action: Action::Allow, - }], - )]), - default: crate::DefaultAction::Deny, - }; - let check = PolicyCheck::with_variables( - Arc::new(policy), - Arc::new(BTreeMap::from([("user".to_string(), "ada".to_string())])), - ); - let read = |path: &str, cwd: &str| { - check.check_with_cwd("main", "fs.read", &serde_json::json!({ "path": path }), cwd) - }; - assert!(matches!( - read("notes.md", "/ada"), - CheckOutcome::Allow { .. } - )); - assert!(matches!( - read("../grace/notes.md", "/ada"), - CheckOutcome::Deny { .. } - )); - } - - #[tokio::test] - async fn the_secret_provider_reads_undeclared_and_missing_secrets_as_absent() { - struct Secrets; - #[async_trait] - impl SecretResolver for Secrets { - async fn resolve(&self, name: &str) -> Result { - match name { - "TOKEN" => Ok("t".to_string()), - "UNSET" => Err(AuthError::MissingSecret(name.to_string())), - "BROKEN" => Err(AuthError::Other("store down".to_string())), - _ => Err(AuthError::UndeclaredSecret(name.to_string())), - } - } - } - let provider = PolicySecretProvider::new(Arc::new(Secrets)); - assert_eq!(provider.get("TOKEN").await, Ok(Some("t".to_string()))); - assert_eq!(provider.get("UNSET").await, Ok(None)); - assert_eq!(provider.get("OTHER").await, Ok(None)); - assert_eq!(provider.get("BROKEN").await, Err("store down".to_string())); - } - - #[test] - fn normalized_policy_paths_are_vfs_path_fields_in_the_catalog() { - use submilli_engine::stdlib::capabilities::{FieldNormalization, catalog}; - for capability in catalog().iter().flat_map(|group| group.capabilities) { - for field in filesystem_path_fields(capability.name) { - let normalization = capability - .filter_fields - .iter() - .find(|candidate| candidate.name == *field) - .map(|candidate| candidate.normalization); - assert_eq!( - normalization, - Some(FieldNormalization::VfsPath), - "{}.{field}", - capability.name - ); - } - } - } -} diff --git a/crates/submilli-policy/src/lib.rs b/crates/submilli-policy/src/lib.rs deleted file mode 100644 index e75b195ff..000000000 --- a/crates/submilli-policy/src/lib.rs +++ /dev/null @@ -1,40 +0,0 @@ -//! The Submilli policy engine: permission rules and their filter language, -//! session variables, and auth-proxy injection. -//! -//! Format-neutral: nothing here knows where a policy is written down. A -//! blueprint file is one source (`submilli-blueprint`); an embedder that keeps -//! policy elsewhere builds these types from its own and evaluates them the same -//! way. - -mod auth_proxy; -mod filter; -#[cfg(feature = "engine")] -pub mod host; -mod permissions; -#[doc(hidden)] -pub mod serde_support; -mod variables; - -pub use auth_proxy::{ - AuthError, AuthProxyPolicy, AuthProxyRule, AuthSpec, BasicAuth, Injections, SecretResolver, - interpolate, resolve_injections, secret_refs, -}; -pub use filter::{ - ComparisonFailure, FailureReason, FieldMatch, FilterEvaluation, FilterExpr, VarBindings, -}; -pub use permissions::{ - Action, DefaultAction, NearMiss, PermissionRule, Policy, Resolution, ResolutionCause, RuleRef, - Rules, -}; -/// The [`Policy`] methods over borrowed rules, for a format that keeps its rules -/// in place rather than building a `Policy`. -#[doc(hidden)] -pub use permissions::{explain, resolve, resolve_with_rule}; -pub use variables::{VariableDecl, VariableError, resolve_variables}; - -/// Tooling over the filter language that is not part of the evaluation API: -/// quoting, name checks and expression structure, for editors and diffs. -#[doc(hidden)] -pub mod filter_syntax { - pub use crate::filter::{is_field_name, is_valid_var_name, parse, quote_literal}; -} diff --git a/crates/submilli-policy/src/permissions.rs b/crates/submilli-policy/src/permissions.rs deleted file mode 100644 index c0a87cead..000000000 --- a/crates/submilli-policy/src/permissions.rs +++ /dev/null @@ -1,557 +0,0 @@ -//! Permission rules — the per-caller capability rules the semantic-security -//! engine evaluates, the blueprint's `permissions:` block. Keyed by caller identifier (`main` for -//! the user script, package name for library code), each caller maps to an -//! ordered rule list walked top-to-bottom, first-match-wins. A caller absent -//! from the map — or a caller whose rules all miss — falls through to the -//! top-level `default`. -//! -//! Each rule's optional `filter` is a [`FilterExpr`] from [`crate::filter`], -//! parsed when the rules are read, so a malformed filter fails then rather than -//! at the first `check()`. - -use std::collections::BTreeMap; - -use serde::{Deserialize, Serialize}; - -use crate::filter::{ComparisonFailure, FilterExpr, VarBindings}; - -/// Fall-through action when no rule matches. Absent in the blueprint, it -/// defaults to `Deny` (deny-by-default): a policy-free blueprint denies every -/// capability. `allow` flips the posture to allow-by-default — every capability -/// is permitted unless a rule denies it — for trusted deployments that prefer a -/// blocklist over an allowlist. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)] -#[serde(rename_all = "kebab-case")] -pub enum DefaultAction { - #[default] - Deny, - Allow, - AskHuman, -} - -/// The action a matched rule (or the fall-through default) resolves to. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[serde(rename_all = "kebab-case")] -pub enum Action { - Allow, - Deny, - AskHuman, -} - -impl From for Action { - fn from(d: DefaultAction) -> Self { - match d { - DefaultAction::Deny => Action::Deny, - DefaultAction::Allow => Action::Allow, - DefaultAction::AskHuman => Action::AskHuman, - } - } -} - -/// One capability rule. The capability name is matched verbatim (no wildcards); -/// flexibility lives in the optional `filter`. -#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct PermissionRule { - /// Label decisions cite this rule by. Unique within a caller block - /// (`blueprint lint` enforces it); the rule's position identifies it - /// otherwise. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub name: Option, - pub capability: String, - #[serde(default, skip_serializing_if = "Option::is_none")] - pub filter: Option, - pub action: Action, -} - -/// Every caller's rules, by caller identifier. -pub type Rules = BTreeMap>; - -/// A complete permission policy: the per-caller rules and what applies when -/// none matches. -#[derive(Debug, Clone, Default, PartialEq)] -pub struct Policy { - pub rules: Rules, - pub default: DefaultAction, -} - -impl Policy { - /// Walk the rules for `caller` and return the resolved action. No caller - /// block, or no rule matching `(capability, ctx)`, falls through to - /// `default`. - pub fn resolve( - &self, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, - ) -> Action { - resolve(&self.rules, self.default, caller, capability, ctx, vars) - } - - /// [`Self::resolve`], with the index of the deciding rule in the caller's - /// block, or `None` when the default decided. - pub fn resolve_with_rule( - &self, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, - ) -> (Action, Option) { - resolve_with_rule(&self.rules, self.default, caller, capability, ctx, vars) - } - - /// [`Self::resolve`], with the reasoning: the deciding rule or default, and - /// the rules for the capability whose filters rejected the call. - pub fn explain( - &self, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, - ) -> Resolution { - explain(&self.rules, self.default, caller, capability, ctx, vars) - } -} - -/// Walk the rules for `caller` and return the resolved action. No caller block, -/// or no rule matching `(capability, ctx)`, falls through to `default`. -pub fn resolve( - permissions: &Rules, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> Action { - resolve_with_rule(permissions, default_action, caller, capability, ctx, vars).0 -} - -/// [`resolve`], with the index of the deciding rule in the caller's block, or -/// `None` when the default decided. -pub fn resolve_with_rule( - permissions: &Rules, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> (Action, Option) { - if let Some(rules) = permissions.get(caller) { - for (index, rule) in rules.iter().enumerate() { - if rule.capability == capability - && rule - .filter - .as_ref() - .is_none_or(|f| f.matches_with(ctx, vars)) - { - return (rule.action, Some(index)); - } - } - } - (default_action.into(), None) -} - -/// A resolved decision with the reasoning behind it. -#[derive(Debug, Clone, PartialEq, Serialize)] -pub struct Resolution { - /// Identical to what [`resolve`] returns for the same inputs. - pub action: Action, - pub cause: ResolutionCause, - /// Rules for the capability, ahead of the deciding rule (or all of them - /// when the default decided), whose filters rejected the call. - pub near_misses: Vec, -} - -#[derive(Debug, Clone, PartialEq, Serialize)] -#[serde(rename_all = "kebab-case", tag = "kind")] -pub enum ResolutionCause { - Rule(RuleRef), - /// No rule matched. `caller_block` is whether the caller has any rules. - Default { - caller_block: bool, - }, -} - -/// A rule located by caller block and zero-based position, with its name when -/// it has one. -#[derive(Debug, Clone, PartialEq, Eq, Serialize)] -pub struct RuleRef { - pub caller: String, - pub index: usize, - pub name: Option, -} - -/// A rule that named the right capability but whose filter rejected the call. -#[derive(Debug, Clone, PartialEq, Serialize)] -pub struct NearMiss { - pub rule: RuleRef, - /// The rule's whole filter, from its `Display` impl. - pub filter: String, - pub failures: Vec, -} - -/// [`resolve`], with the reasoning: the deciding rule or default, and the rules -/// for the capability whose filters rejected the call. -pub fn explain( - permissions: &Rules, - default_action: DefaultAction, - caller: &str, - capability: &str, - ctx: &serde_json::Value, - vars: &VarBindings, -) -> Resolution { - let (action, matched) = - resolve_with_rule(permissions, default_action, caller, capability, ctx, vars); - let rules = permissions.get(caller); - let rule_ref = |index: usize, rule: &PermissionRule| RuleRef { - caller: caller.to_string(), - index, - name: rule.name.clone(), - }; - let cause = match matched.and_then(|index| Some((index, rules?.get(index)?))) { - Some((index, rule)) => ResolutionCause::Rule(rule_ref(index, rule)), - None => ResolutionCause::Default { - caller_block: rules.is_some(), - }, - }; - let walked = matched.unwrap_or(usize::MAX); - let near_misses = rules - .into_iter() - .flatten() - .enumerate() - .take_while(|(index, _)| *index < walked) - .filter(|(_, rule)| rule.capability == capability) - .filter_map(|(index, rule)| { - let filter = rule.filter.as_ref()?; - let evaluation = filter.explain_with(ctx, vars); - (!evaluation.matched).then(|| NearMiss { - rule: rule_ref(index, rule), - filter: filter.to_string(), - failures: evaluation.failures, - }) - }) - .collect(); - Resolution { - action, - cause, - near_misses, - } -} - -#[cfg(test)] -mod tests { - use super::*; - use serde_json::json; - - fn filter(s: &str) -> FilterExpr { - crate::filter::parse(s).expect("valid filter") - } - - /// The shape an embedder that keeps policy outside a blueprint builds: rules - /// whose filters it parsed from its own format, and a default. - #[test] - fn a_policy_built_by_hand_scopes_by_session_variable() { - let policy = Policy { - rules: BTreeMap::from([( - "main".to_string(), - vec![PermissionRule { - name: Some("own tenant".to_string()), - capability: "agent.run".to_string(), - filter: Some("agent == ${vars.agent}".parse().expect("filter")), - action: Action::Allow, - }], - )]), - default: DefaultAction::Deny, - }; - let vars = VarBindings::from([("agent".to_string(), "researcher".to_string())]); - let ctx = |agent: &str| json!({ "agent": agent }); - assert_eq!( - policy.resolve_with_rule("main", "agent.run", &ctx("researcher"), &vars), - (Action::Allow, Some(0)) - ); - assert_eq!( - policy.resolve("main", "agent.run", &ctx("deployer"), &vars), - Action::Deny - ); - let explained = policy.explain("main", "agent.run", &ctx("deployer"), &vars); - assert_eq!(explained.near_misses.len(), 1); - } - - #[test] - fn resolve_first_match_wins() { - let mut perms = BTreeMap::new(); - perms.insert( - "main".to_string(), - vec![ - PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: Some(filter("amount < 500")), - action: Action::Allow, - }, - PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: None, - action: Action::AskHuman, - }, - ], - ); - let allow = resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/charge", - &json!({ "amount": 100 }), - &VarBindings::new(), - ); - assert_eq!(allow, Action::Allow); - let ask = resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/charge", - &json!({ "amount": 900 }), - &VarBindings::new(), - ); - assert_eq!(ask, Action::AskHuman); - } - - #[test] - fn resolve_falls_through_to_default() { - let perms = BTreeMap::new(); - // Caller absent entirely. - assert_eq!( - resolve( - &perms, - DefaultAction::Deny, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::Deny - ); - assert_eq!( - resolve( - &perms, - DefaultAction::AskHuman, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::AskHuman - ); - assert_eq!( - resolve( - &perms, - DefaultAction::Allow, - "main", - "x", - &json!({}), - &VarBindings::new() - ), - Action::Allow - ); - } - - #[test] - fn resolve_capability_is_exact() { - let mut perms = BTreeMap::new(); - perms.insert( - "main".to_string(), - vec![PermissionRule { - name: None, - capability: "stripe.com/charge".into(), - filter: None, - action: Action::Allow, - }], - ); - // No wildcard: a sibling capability falls through to default. - assert_eq!( - resolve( - &perms, - DefaultAction::Deny, - "main", - "stripe.com/refund", - &json!({}), - &VarBindings::new() - ), - Action::Deny - ); - } - - fn rule( - name: Option<&str>, - capability: &str, - f: Option<&str>, - action: Action, - ) -> PermissionRule { - PermissionRule { - name: name.map(str::to_string), - capability: capability.into(), - filter: f.map(filter), - action, - } - } - - fn vars(pairs: &[(&str, &str)]) -> VarBindings { - pairs - .iter() - .map(|(k, v)| (k.to_string(), v.to_string())) - .collect() - } - - fn explain_main( - rules: Vec, - default: DefaultAction, - capability: &str, - ctx: serde_json::Value, - bindings: &VarBindings, - ) -> Resolution { - let perms = BTreeMap::from([("main".to_string(), rules)]); - let resolution = explain(&perms, default, "main", capability, &ctx, bindings); - // The explanation never disagrees with enforcement. - assert_eq!( - resolution.action, - resolve(&perms, default, "main", capability, &ctx, bindings) - ); - resolution - } - - #[test] - fn explain_filter_miss_is_a_near_miss_under_default() { - let resolution = explain_main( - vec![rule( - Some("own-customer"), - "acme.com/charges.list", - Some("customerId == ${vars.customerId}"), - Action::Allow, - )], - DefaultAction::Deny, - "acme.com/charges.list", - json!({ "customerId": "cus_initech" }), - &vars(&[("customerId", "cus_northwind")]), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Default { caller_block: true } - ); - let [miss] = resolution.near_misses.as_slice() else { - panic!("expected one near miss: {resolution:?}"); - }; - assert_eq!(miss.rule.index, 0); - assert_eq!(miss.rule.name.as_deref(), Some("own-customer")); - assert_eq!(miss.filter, "customerId == ${vars.customerId}"); - let [failure] = miss.failures.as_slice() else { - panic!("expected one failure: {miss:?}"); - }; - assert_eq!(failure.comparison, "customerId == ${vars.customerId}"); - assert_eq!(failure.actual, Some(json!("cus_initech"))); - assert_eq!(failure.expected.as_deref(), Some("cus_northwind")); - } - - #[test] - fn explain_second_rule_match_cites_index_and_name() { - let resolution = explain_main( - vec![ - rule( - None, - "stripe.com/charge", - Some("amount < 500"), - Action::Allow, - ), - rule(Some("big-charges"), "stripe.com/charge", None, Action::Deny), - ], - DefaultAction::Allow, - "stripe.com/charge", - json!({ "amount": 900 }), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Rule(RuleRef { - caller: "main".into(), - index: 1, - name: Some("big-charges".into()), - }) - ); - // The earlier rule that rejected the call is still reported. - assert_eq!(resolution.near_misses.len(), 1); - assert_eq!(resolution.near_misses[0].rule.index, 0); - assert_eq!(resolution.near_misses[0].rule.name, None); - } - - #[test] - fn explain_without_caller_block_reports_it() { - let perms = BTreeMap::new(); - let resolution = explain( - &perms, - DefaultAction::Deny, - "main", - "x", - &json!({}), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::Deny); - assert_eq!( - resolution.cause, - ResolutionCause::Default { - caller_block: false - } - ); - assert!(resolution.near_misses.is_empty()); - } - - #[test] - fn explain_ask_human_stays_distinct_and_names_the_rule() { - let resolution = explain_main( - vec![rule( - Some("review-refunds"), - "stripe.com/refund", - None, - Action::AskHuman, - )], - DefaultAction::Deny, - "stripe.com/refund", - json!({}), - &VarBindings::new(), - ); - assert_eq!(resolution.action, Action::AskHuman); - let ResolutionCause::Rule(rule) = &resolution.cause else { - panic!("expected a rule cause: {resolution:?}"); - }; - assert_eq!(rule.name.as_deref(), Some("review-refunds")); - } - - #[test] - fn explain_unbound_variable_failure() { - let resolution = explain_main( - vec![rule(None, "x", Some("id == ${vars.x}"), Action::Allow)], - DefaultAction::Deny, - "x", - json!({ "id": "a" }), - &VarBindings::new(), - ); - assert_eq!( - resolution.near_misses[0].failures[0].reason, - crate::filter::FailureReason::VariableNotBound("x".into()) - ); - } - - #[test] - fn explain_ignores_other_capabilities() { - let resolution = explain_main( - vec![rule(None, "a", Some("n == 1"), Action::Allow)], - DefaultAction::Deny, - "b", - json!({ "n": 2 }), - &VarBindings::new(), - ); - assert!(resolution.near_misses.is_empty()); - } -} diff --git a/crates/submilli-policy/src/serde_support.rs b/crates/submilli-policy/src/serde_support.rs deleted file mode 100644 index d2bcec792..000000000 --- a/crates/submilli-policy/src/serde_support.rs +++ /dev/null @@ -1,124 +0,0 @@ -//! Serde helpers shared by the policy types and the formats that embed them. -//! Not part of the policy API. - -use std::collections::BTreeMap; -use std::fmt; -use std::marker::PhantomData; - -use serde::{Deserialize, Deserializer, de}; - -/// Name-keyed maps must not silently replace an earlier declaration. -pub fn unique_map<'de, D, V>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, - V: Deserialize<'de>, -{ - deserializer.deserialize_map(UniqueNames(PhantomData)) -} - -struct UniqueNames(PhantomData); - -impl<'de, V: Deserialize<'de>> de::Visitor<'de> for UniqueNames { - type Value = BTreeMap; - - fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { - formatter.write_str("a map with unique names") - } - - fn visit_map>(self, mut map: A) -> Result { - let mut names = BTreeMap::new(); - while let Some(name) = map.next_key::()? { - if names.contains_key(&name) { - map.next_value_seed(Reject::::new(format!( - "duplicate key `{name}`: remove or rename the repeated declaration" - )))?; - continue; - } - let value = map.next_value()?; - names.insert(name, value); - } - Ok(names) - } -} - -/// A map value whose deserialization always fails, standing in for a value of -/// type `T` so it can replace any field's seed. -/// -/// Raising the error from *inside* the value is what anchors the diagnostic at -/// that key: an error returned from the enclosing map's visitor carries only the -/// map's path, which is too coarse for an editor to squiggle the offending line. -/// Failing from within the visitor rather than after consuming the node also -/// keeps the parser's mark on the value, so the reported line is the offending -/// one and not the first line of the block. -pub struct Reject(String, PhantomData); - -impl Reject { - pub fn new(message: impl Into) -> Self { - Reject(message.into(), PhantomData) - } - - fn fail(self) -> Result { - Err(de::Error::custom(self.0)) - } -} - -impl<'de, T> de::DeserializeSeed<'de> for Reject { - type Value = T; - - fn deserialize(self, deserializer: D) -> Result - where - D: serde::Deserializer<'de>, - { - deserializer.deserialize_any(self) - } -} - -// Every shape of value gets the same message; the default `Visitor` methods -// would replace it with serde's own `invalid type` wording. -impl<'de, T> de::Visitor<'de> for Reject { - type Value = T; - - fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(&self.0) - } - - fn visit_bool(self, _: bool) -> Result { - self.fail() - } - - fn visit_i64(self, _: i64) -> Result { - self.fail() - } - - fn visit_u64(self, _: u64) -> Result { - self.fail() - } - - fn visit_f64(self, _: f64) -> Result { - self.fail() - } - - fn visit_str(self, _: &str) -> Result { - self.fail() - } - - fn visit_bytes(self, _: &[u8]) -> Result { - self.fail() - } - - fn visit_unit(self) -> Result { - self.fail() - } - - fn visit_seq>(self, _: A) -> Result { - self.fail() - } - - fn visit_map>(self, _: A) -> Result { - self.fail() - } - - fn visit_enum>(self, _: A) -> Result { - self.fail() - } -} diff --git a/crates/submilli-policy/src/variables.rs b/crates/submilli-policy/src/variables.rs deleted file mode 100644 index dbb6b973b..000000000 --- a/crates/submilli-policy/src/variables.rs +++ /dev/null @@ -1,86 +0,0 @@ -//! Session variables: operator-declared, caller-supplied named values bound once -//! per session and referenced as `${vars.NAME}` in permission filters. Unlike a -//! secret (whose value the program never sees, injected only into outbound -//! auth), a variable *is* the value, matched against in a filter to scope a -//! capability to per-session data (e.g. a tenant id). - -use std::collections::BTreeMap; -use std::fmt; - -use serde::{Deserialize, Serialize}; - -/// One declared variable. `required` and `default` are mutually exclusive: a -/// required variable with a default is contradictory (rejected at parse). -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[serde(deny_unknown_fields)] -pub struct VariableDecl { - /// The session is rejected at init if this variable is missing or empty. - #[serde(default, skip_serializing_if = "is_false")] - pub required: bool, - /// Value bound when the caller supplies none. - #[serde(default, skip_serializing_if = "Option::is_none")] - pub default: Option, -} - -fn is_false(b: &bool) -> bool { - !*b -} - -/// A failure binding caller-supplied variables against the blueprint's -/// declarations, surfaced at session init (REST → 400, MCP → failed -/// `initialize`). -#[derive(Debug, Clone, PartialEq, Eq)] -pub enum VariableError { - /// A `required` variable was not supplied (or supplied empty). - MissingRequired(String), - /// A supplied variable name is not declared in the blueprint. - Unknown(String), -} - -impl fmt::Display for VariableError { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - VariableError::MissingRequired(name) => { - write!(f, "required variable '{name}' was not supplied") - } - VariableError::Unknown(name) => { - write!(f, "variable '{name}' is not declared in the blueprint") - } - } - } -} - -impl std::error::Error for VariableError {} - -/// Bind caller-supplied values against the declarations: fill defaults, reject a -/// missing/empty `required` variable, reject any supplied name that isn't -/// declared. Returns the resolved bindings filter evaluation reads. An optional -/// variable with no value and no default is simply omitted — an absent -/// `${vars.NAME}` is a non-match at eval, never a trap. -pub fn resolve_variables( - decls: &BTreeMap, - supplied: &BTreeMap, -) -> Result, VariableError> { - for name in supplied.keys() { - if !decls.contains_key(name) { - return Err(VariableError::Unknown(name.clone())); - } - } - let mut resolved = BTreeMap::new(); - for (name, decl) in decls { - match supplied.get(name) { - Some(value) if !value.is_empty() => { - resolved.insert(name.clone(), value.clone()); - } - _ => { - if decl.required { - return Err(VariableError::MissingRequired(name.clone())); - } - if let Some(default) = &decl.default { - resolved.insert(name.clone(), default.clone()); - } - } - } - } - Ok(resolved) -} diff --git a/crates/submilli-policy/tests/engine_literal_parity.rs b/crates/submilli-policy/tests/engine_literal_parity.rs deleted file mode 100644 index a2da63821..000000000 --- a/crates/submilli-policy/tests/engine_literal_parity.rs +++ /dev/null @@ -1,68 +0,0 @@ -//! The engine writes filters into a package's derived requirements without -//! depending on this crate, so its quoting is a second copy of -//! [`quote_literal`]. These tests keep the two in step, and check that every -//! field name the engine's capability catalog offers can be written in a -//! filter. - -use submilli_engine::capability_derivation::filter_string_literal; -use submilli_engine::stdlib::capabilities; -use submilli_engine::{OptionalPackage, Stdlib}; -use submilli_policy::filter_syntax::{is_field_name, parse, quote_literal}; - -const CORPUS: &[&str] = &[ - "", - "plain", - "with \"quotes\"", - "back\\slash", - "line\nbreak", - "tab\tand\rreturn", - "${vars.x}", - "prefix ${vars.tenant} suffix", - "${other}", - "$", - "{", - "}", - "${", - "${vars", - "naïve — ünïcödé ✓", - "/repos/acme/*", -]; - -#[test] -fn the_engine_quotes_every_value_as_the_policy_does() { - for value in CORPUS { - assert_eq!( - filter_string_literal(value), - quote_literal(value), - "{value:?}" - ); - } -} - -#[test] -fn a_quoted_value_reads_back_as_itself() { - for value in CORPUS { - let Some(literal) = filter_string_literal(value) else { - continue; - }; - let filter = parse(&format!("f == {literal}")).expect("parses"); - assert!( - filter.matches(&serde_json::json!({ "f": value })), - "{value:?} as {literal}" - ); - } -} - -#[test] -fn every_cataloged_field_can_be_written_in_a_filter() { - let every = Stdlib::core() - .with(OptionalPackage::Agents) - .with(OptionalPackage::Skills); - for group in capabilities::catalog_for(every) { - for capability in group.capabilities { - for field in capability.field_names() { - assert!(is_field_name(field), "{}: {field}", capability.name); - } - } - } -} diff --git a/crates/submilli-server/src/handlers/execute.rs b/crates/submilli-server/src/handlers/execute.rs index d3668d449..56298fcd6 100644 --- a/crates/submilli-server/src/handlers/execute.rs +++ b/crates/submilli-server/src/handlers/execute.rs @@ -569,7 +569,7 @@ async fn prepare_and_run( }; let manager = state.session_manager(); let policy: Arc = Arc::new( - PolicyCheck::with_variables(Arc::new(blueprint.policy()), Arc::clone(&variables)), + PolicyCheck::with_variables(Arc::clone(&blueprint), Arc::clone(&variables)), ); let security_check = execution_audit.as_ref().map_or_else( || policy.clone(), diff --git a/crates/submilli-server/src/mcp/server.rs b/crates/submilli-server/src/mcp/server.rs index 62e64a3ec..4b9125839 100644 --- a/crates/submilli-server/src/mcp/server.rs +++ b/crates/submilli-server/src/mcp/server.rs @@ -761,10 +761,8 @@ impl SubmilliMcp { .map_err(|error| FileToolError::file(path, error.into()))?; let recording = self.file_tool_recording(parts, &blueprint, &variables, tool.name); let log = recording.as_ref().map(crate::record::Recording::log); - let policy: Arc = Arc::new(PolicyCheck::with_variables( - Arc::new(blueprint.policy()), - variables, - )); + let policy: Arc = + Arc::new(PolicyCheck::with_variables(blueprint.clone(), variables)); let policy = log.as_ref().map_or(policy.clone(), |log| log.wrap(policy)); let call = policy.recorder().map(|recorder| { let marker = recorder.enter_host_call(); diff --git a/crates/submilli-server/tests/decision_records_policy.rs b/crates/submilli-server/tests/decision_records_policy.rs index 6a49dbced..60de610e9 100644 --- a/crates/submilli-server/tests/decision_records_policy.rs +++ b/crates/submilli-server/tests/decision_records_policy.rs @@ -25,7 +25,7 @@ async fn a_recorded_run_cites_an_unnormalizable_path_as_a_runtime_invariant() { data.install_type_info(script.type_info.clone()); // Under `default: allow`, only the path keeps this call from being allowed. data.security_check = Arc::new(PolicyCheck::new(Arc::new( - parse("name: open\ndefault: allow\n").unwrap().policy(), + parse("name: open\ndefault: allow\n").unwrap(), ))); let log = DecisionLog::install(&mut data, DecisionLogConfig::default()); let mut store = cfg.store_async(&engine, data).unwrap(); diff --git a/crates/submilli-server/tests/replay.rs b/crates/submilli-server/tests/replay.rs index a9a77acb3..1b5c6d639 100644 --- a/crates/submilli-server/tests/replay.rs +++ b/crates/submilli-server/tests/replay.rs @@ -312,7 +312,7 @@ async fn run(source: &str, setup: Setup) -> Outcome { None, Arc::new(setup.secrets), )); - data.security_check = Arc::new(PolicyCheck::new(Arc::new(blueprint.policy()))); + data.security_check = Arc::new(PolicyCheck::new(blueprint)); if let Some(llm) = setup.llm { data.llm_provider = Some(llm); } diff --git a/crates/submilli-shared/Cargo.toml b/crates/submilli-shared/Cargo.toml index cca220dac..7b4a9cfdd 100644 --- a/crates/submilli-shared/Cargo.toml +++ b/crates/submilli-shared/Cargo.toml @@ -15,7 +15,6 @@ path = "src/lib.rs" [dependencies] interpreter = { package = "submilli-engine", path = "../interpreter" } submilli-blueprint = { path = "../submilli-blueprint" } -submilli-policy = { path = "../submilli-policy", features = ["engine"] } submilli-build = { path = "../submilli-build" } anyhow = { workspace = true } sha2 = "0.10" diff --git a/crates/submilli-shared/src/host.rs b/crates/submilli-shared/src/host.rs index 28f968a60..a843c473e 100644 --- a/crates/submilli-shared/src/host.rs +++ b/crates/submilli-shared/src/host.rs @@ -1,20 +1,254 @@ -//! Embedder glue that wires a [`Blueprint`] into the runtime's host-service -//! traits ([`AuthProxy`], [`SecretProvider`], and `SecurityCheck` through -//! [`PolicyCheck`]). The adapters themselves live in `submilli-policy`; this -//! ties them to the blueprint's `secrets:` block and the server's secret store. +//! Embedder glue that adapts a [`Blueprint`] to the runtime's host-service +//! traits ([`SecurityCheck`], [`AuthProxy`], [`SecretProvider`]). The policy +//! logic, filter matching, and `${secrets.X}` interpolation live in +//! `submilli-blueprint`; this is the thin `interpreter`-facing layer that an +//! embedder (the server, or local-dev `submilli run --blueprint`) installs onto +//! a `StoreData`. It lives here rather than in `submilli-blueprint` so that +//! crate stays free of the `interpreter` dependency. +use std::borrow::Cow; use std::sync::Arc; use async_trait::async_trait; -use interpreter::runtime::{AuthProxy, AuthProxyError, HttpRequest, SecretProvider}; +use interpreter::runtime::{ + AuthProxy, AuthProxyError, CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, + FailureReasonRecord, FailureRecord, HttpRequest, NearMissRecord, RuleCitation, SecretProvider, + SecurityCheck, +}; +use interpreter::stdlib::http::HttpTransportPolicy; +use url::Url; + +use std::collections::BTreeMap; + use submilli_blueprint::{ - AuthError, Blueprint, DeclaredSecrets, HarnessSecretBindings, SecretSource, - SourceSecretResolver, + Action, AuthError, Blueprint, ComparisonFailure, FailureReason, HarnessSecretBindings, + Injections, NearMiss, Resolution, ResolutionCause, RuleRef, SecretResolver, SecretSource, + VarBindings, resolve_injections, }; -use submilli_policy::SecretResolver; -use submilli_policy::host::{PolicyAuthProxy, PolicySecretProvider}; -pub use submilli_policy::host::PolicyCheck; +/// The package name auth-proxy injection is scoped to. Matches the name the runtime gives a +/// user script's module, which is what it reads off the running wasm frame to identify a +/// caller. +const MAIN_PACKAGE: &str = "main"; + +// ---- SecurityCheck ------------------------------------------------------- + +/// Blueprint-driven [`SecurityCheck`]: evaluates the blueprint's `permissions:` +/// rules for each capability check. +/// +/// Deny-by-default: a capability is allowed only when a rule says so, and a +/// policy-free blueprint (no `permissions:`, no `default:`) denies every +/// capability. `default: allow` inverts this to allow-by-default. `ask-human` +/// is deferred (no suspend/resume yet), so it resolves to `Deny` with a reason +/// that says so. +/// +/// Filesystem rules see absolute guest paths with `.` and `..` collapsed using +/// the same lexical resolver as VFS I/O. This also applies to both endpoints of +/// copy/move and the destination of HTTP downloads. It does not resolve symlinks. +pub struct PolicyCheck { + blueprint: Arc, + /// Caller-supplied `${vars.NAME}` bindings for this session, resolved at + /// session init. Empty for callers that bind no variables. + variables: Arc, +} + +impl PolicyCheck { + pub fn new(blueprint: Arc) -> Self { + Self::with_variables(blueprint, Arc::new(BTreeMap::new())) + } + + /// As [`Self::new`], with the session's resolved variable bindings threaded + /// into every `${vars.NAME}` filter operand. + pub fn with_variables(blueprint: Arc, variables: Arc) -> Self { + PolicyCheck { + blueprint, + variables, + } + } +} + +impl SecurityCheck for PolicyCheck { + fn audit_context<'a>( + &self, + capability: &str, + context: &'a serde_json::Value, + cwd: &str, + ) -> Cow<'a, serde_json::Value> { + filesystem_policy_context(capability, context, cwd).unwrap_or(Cow::Borrowed(context)) + } + + fn check(&self, caller: &str, capability: &str, context: &serde_json::Value) -> CheckOutcome { + self.check_with_cwd(caller, capability, context, "/") + } + + fn explain( + &self, + caller: &str, + capability: &str, + context: &serde_json::Value, + cwd: &str, + ) -> Option { + let context = match filesystem_policy_context(capability, context, cwd) { + Ok(context) => context, + // `check_with_cwd` refuses these before resolution: no rule can grant them. + Err(reason) => { + return Some(DecisionExplanation { + action: DecisionAction::Deny, + cause: DecisionCause::RuntimeInvariant { reason }, + near_misses: Vec::new(), + }); + } + }; + let resolution = + self.blueprint + .explain_permission(caller, capability, &context, &self.variables); + Some(explanation_of(resolution)) + } + + fn check_with_cwd( + &self, + caller: &str, + capability: &str, + context: &serde_json::Value, + cwd: &str, + ) -> CheckOutcome { + let context = match filesystem_policy_context(capability, context, cwd) { + Ok(context) => context, + Err(reason) => return CheckOutcome::Deny { reason, rule: None }, + }; + let (action, rule) = self.blueprint.resolve_permission_with_rule( + caller, + capability, + &context, + &self.variables, + ); + match action { + Action::Allow => CheckOutcome::Allow { rule }, + Action::Deny => CheckOutcome::Deny { + rule, + reason: format!( + "policy denied {capability}{} for {caller}", + filesystem_target(capability, &context) + ), + }, + Action::AskHuman => CheckOutcome::Deny { + rule, + reason: format!( + "policy requires human approval for {capability}{} (caller {caller}); \ + ask-human is deferred and treated as deny", + filesystem_target(capability, &context) + ), + }, + } + } +} + +fn explanation_of(resolution: Resolution) -> DecisionExplanation { + DecisionExplanation { + action: match resolution.action { + Action::Allow => DecisionAction::Allow, + Action::Deny => DecisionAction::Deny, + Action::AskHuman => DecisionAction::AskHuman, + }, + cause: cause_of(resolution.cause), + near_misses: resolution + .near_misses + .into_iter() + .map(near_miss_record) + .collect(), + } +} + +fn citation(rule: RuleRef) -> RuleCitation { + RuleCitation { + caller: rule.caller, + index: rule.index, + name: rule.name, + } +} + +fn cause_of(cause: ResolutionCause) -> DecisionCause { + match cause { + ResolutionCause::Rule(rule) => DecisionCause::Rule(citation(rule)), + ResolutionCause::Default { caller_block } => DecisionCause::Default { caller_block }, + } +} + +fn near_miss_record(miss: NearMiss) -> NearMissRecord { + NearMissRecord { + rule: citation(miss.rule), + filter: miss.filter, + failures: miss.failures.into_iter().map(failure_record).collect(), + } +} + +fn failure_record(failure: ComparisonFailure) -> FailureRecord { + let reason = match failure.reason { + FailureReason::FieldMissing => FailureReasonRecord::FieldMissing, + FailureReason::VariableNotBound(name) => FailureReasonRecord::VariableNotBound(name), + FailureReason::NotSatisfied => FailureReasonRecord::NotSatisfied, + }; + FailureRecord { + comparison: failure.comparison, + actual: failure.actual, + expected: failure.expected, + reason, + negated: failure.negated, + } +} + +/// The normalized VFS paths a denial was for, so a narrowed filter can be fixed +/// from the message. The library may have probed a path on the program's +/// behalf, as `submilli:code` does for ignore files, so the program's own +/// arguments do not always name it. Empty for capabilities without VFS paths. +fn filesystem_target(capability: &str, context: &serde_json::Value) -> String { + let path = |field: &&str| context.get(*field).and_then(serde_json::Value::as_str); + match filesystem_path_fields(capability) { + [single] => path(single).map_or_else(String::new, |path| format!(" on {path}")), + [from, to] => match (path(from), path(to)) { + (Some(from), Some(to)) => format!(" from {from} to {to}"), + _ => String::new(), + }, + _ => String::new(), + } +} + +/// The context fields of a capability that hold VFS paths. +fn filesystem_path_fields(capability: &str) -> &'static [&'static str] { + match capability { + "fs.read" | "fs.write" | "fs.stat" | "fs.list" | "fs.mkdir" | "fs.remove" => &["path"], + "fs.copy" | "fs.move" => &["from", "to"], + "git.init" | "git.clone" | "git.fetch" | "git.commit" => &["path"], + "http.download" => &["vfs_path"], + _ => &[], + } +} + +/// Keep policy paths in the same guest namespace as the subsequent VFS operation. +/// Normalization is lexical and performs no I/O, so a denial cannot reveal whether +/// the target exists. URL paths and application-defined capabilities stay untouched. +fn filesystem_policy_context<'a>( + capability: &str, + context: &'a serde_json::Value, + cwd: &str, +) -> Result, String> { + let fields = filesystem_path_fields(capability); + let mut normalized_context = Cow::Borrowed(context); + for &field in fields { + let path = context + .get(field) + .and_then(serde_json::Value::as_str) + .ok_or_else(|| { + format!("invalid {capability} context: {field} must be a VFS path string") + })?; + let normalized = interpreter::runtime::fs::guest_normalize(cwd, path) + .map_err(|error| format!("invalid {capability} {field}: {error}"))?; + if normalized != path { + normalized_context.to_mut()[field] = serde_json::Value::String(normalized); + } + } + Ok(normalized_context) +} // ---- SecretStore --------------------------------------------------------- @@ -74,7 +308,7 @@ impl BlueprintSecretResolver { } #[async_trait] -impl SourceSecretResolver for BlueprintSecretResolver { +impl SecretResolver for BlueprintSecretResolver { async fn resolve(&self, name: &str, source: &SecretSource) -> Result { match source { // On-demand decrypt: reads + opens the one sealed file, awaited so the @@ -100,39 +334,12 @@ impl SourceSecretResolver for BlueprintSecretResolver { } } -/// A blueprint's declared secrets as a policy [`SecretResolver`]: a name the -/// `secrets:` block does not declare is undeclared, and a declared one resolves -/// from its source. The owning form of [`DeclaredSecrets`], for the adapters -/// that keep a resolver for the life of a session. -pub struct BlueprintSecrets { +/// Blueprint-backed provider for script-visible `submilli:secrets.get`. +pub struct BlueprintSecretProvider { blueprint: Arc, resolver: BlueprintSecretResolver, } -impl BlueprintSecrets { - pub fn new(blueprint: Arc, resolver: BlueprintSecretResolver) -> Self { - Self { - blueprint, - resolver, - } - } -} - -#[async_trait] -impl SecretResolver for BlueprintSecrets { - async fn resolve(&self, name: &str) -> Result { - DeclaredSecrets { - blueprint: &self.blueprint, - inner: &self.resolver, - } - .resolve(name) - .await - } -} - -/// Blueprint-backed provider for script-visible `submilli:secrets.get`. -pub struct BlueprintSecretProvider(PolicySecretProvider); - impl BlueprintSecretProvider { pub fn new(blueprint: Arc, store: Option>) -> Self { Self::with_harness(blueprint, store, Arc::new(HarnessSecretBindings::new())) @@ -143,11 +350,10 @@ impl BlueprintSecretProvider { store: Option>, harness: Arc, ) -> Self { - let secrets = BlueprintSecrets::new( + Self { blueprint, - BlueprintSecretResolver::with_harness(store, harness), - ); - Self(PolicySecretProvider::new(Arc::new(secrets))) + resolver: BlueprintSecretResolver::with_harness(store, harness), + } } } @@ -158,7 +364,16 @@ impl SecretProvider for BlueprintSecretProvider { ) -> std::pin::Pin< Box, String>> + Send + 'a>, > { - self.0.get(name) + Box::pin(async move { + let Some(source) = self.blueprint.secrets.get(name) else { + return Ok(None); + }; + match self.resolver.resolve(name, source).await { + Ok(value) => Ok(Some(value)), + Err(AuthError::UndeclaredSecret(_) | AuthError::MissingSecret(_)) => Ok(None), + Err(AuthError::Other(msg)) => Err(msg), + } + }) } } @@ -167,7 +382,12 @@ impl SecretProvider for BlueprintSecretProvider { /// [`AuthProxy`] backed by a blueprint's `auth_proxy:` + `secrets:` blocks. /// Injects the matching rule's headers / query params (with `${secrets.X}` /// resolved) into outbound `submilli:http` calls made by `main`. -pub struct BlueprintAuthProxy(PolicyAuthProxy); +pub struct BlueprintAuthProxy { + transport_policy: Arc, + authenticated_policy: Arc, + blueprint: Arc, + resolver: BlueprintSecretResolver, +} impl BlueprintAuthProxy { pub fn new(blueprint: Arc, store: Option>) -> Self { @@ -179,12 +399,25 @@ impl BlueprintAuthProxy { store: Option>, harness: Arc, ) -> Self { - let policy = blueprint.auth_proxy_policy(); - let secrets = BlueprintSecrets::new( + let transport_policy = HttpTransportPolicy { + allow_insecure_http: blueprint.allow_insecure_http, + auth_proxy_hosts: blueprint + .auth_proxy + .iter() + .map(|rule| (rule.host.clone(), rule.allow_insecure_http)) + .collect(), + same_origin_redirects: false, + }; + let authenticated_policy = Arc::new(HttpTransportPolicy { + same_origin_redirects: true, + ..transport_policy.clone() + }); + Self { + transport_policy: Arc::new(transport_policy), + authenticated_policy, blueprint, - BlueprintSecretResolver::with_harness(store, harness), - ); - Self(PolicyAuthProxy::new(policy, Arc::new(secrets))) + resolver: BlueprintSecretResolver::with_harness(store, harness), + } } } @@ -192,36 +425,94 @@ impl BlueprintAuthProxy { impl AuthProxy for BlueprintAuthProxy { async fn transform( &self, - req: HttpRequest, + mut req: HttpRequest, caller: &str, ) -> Result { - self.0.transform(req, caller).await + req.transport_policy = Some(Arc::clone(&self.transport_policy)); + // Check every caller before resolving credentials, including package calls. + let url = + Url::parse(&req.url).map_err(|_| AuthProxyError::Other("invalid HTTP URL".into()))?; + self.transport_policy + .check_destination(&url) + .map_err(|error| AuthProxyError::Other(error.to_string()))?; + if caller != MAIN_PACKAGE { + return Ok(req); + } + let Some(host) = url.host_str() else { + return Ok(req); + }; + let Some(injections) = resolve_injections(&self.blueprint, host, &self.resolver) + .await + .map_err(to_proxy_error)? + else { + return Ok(req); + }; + req.transport_policy = Some(Arc::clone(&self.authenticated_policy)); + apply(&mut req, injections); + Ok(req) } } -#[cfg(test)] -mod tests { - use std::collections::BTreeMap; - - use interpreter::runtime::{ - CheckOutcome, DecisionAction, DecisionCause, DecisionExplanation, FailureReasonRecord, - RuleCitation, SecurityCheck, - }; - use submilli_blueprint::{Policy, parse}; - use url::Url; +/// Apply injections; the blueprint value overrides any the script set itself. +fn apply(req: &mut HttpRequest, injections: Injections) { + for (name, value) in injections.headers { + let key = name.to_ascii_lowercase(); // host stores header names lowercased + req.headers.retain(|(k, _)| *k != key); + req.headers.push((key, value)); + } + if !injections.query.is_empty() + && let Ok(url) = Url::parse(&req.url) + { + req.url = with_query(&url, &injections.query); + } +} - use super::*; +/// Rebuild the URL's query string: keep the script's params except those the +/// blueprint sets (blueprint wins), then append the injected ones. +fn with_query(url: &Url, injected: &[(String, String)]) -> String { + let overridden: Vec<&str> = injected.iter().map(|(k, _)| k.as_str()).collect(); + let kept: Vec<(String, String)> = url + .query_pairs() + .filter(|(k, _)| !overridden.contains(&k.as_ref())) + .map(|(k, v)| (k.into_owned(), v.into_owned())) + .collect(); + let mut out = url.clone(); + { + let mut pairs = out.query_pairs_mut(); + pairs.clear(); + for (k, v) in &kept { + pairs.append_pair(k, v); + } + for (k, v) in injected { + pairs.append_pair(k, v); + } + } + // `query_pairs_mut().clear()` on an originally-empty query leaves a bare `?`. + if out.query() == Some("") { + out.set_query(None); + } + out.to_string() +} - fn policy_of(blueprint: Blueprint) -> Arc { - Arc::new(blueprint.policy()) +fn to_proxy_error(err: AuthError) -> AuthProxyError { + match err { + AuthError::UndeclaredSecret(name) => AuthProxyError::UndeclaredSecret(name), + AuthError::MissingSecret(name) => AuthProxyError::MissingSecret(name), + AuthError::Other(msg) => AuthProxyError::Other(msg), } +} + +#[cfg(test)] +mod tests { + use super::*; + use submilli_blueprint::parse; /// Call-site derivation normalizes the same fields from the catalog, so a /// derived `requires` filter names the path this check sees. #[test] fn working_directory_is_used_for_all_filesystem_policy_fields() { let blueprint = parse("name: cwd\ndefault: deny\npermissions:\n main:\n - {capability: fs.read, action: allow, filter: 'path glob \"/notes/*\"'}\n - {capability: fs.move, action: allow, filter: 'from glob \"/notes/*\" and to glob \"/notes/*\"'}\n - {capability: http.download, action: allow, filter: 'vfs_path glob \"/notes/*\"'}\n").unwrap(); - let policy = PolicyCheck::new(policy_of(blueprint)); + let policy = PolicyCheck::new(Arc::new(blueprint)); for (capability, context) in [ ("fs.read", serde_json::json!({"path":"a"})), ("fs.move", serde_json::json!({"from":"a", "to":"b"})), @@ -248,7 +539,7 @@ mod tests { } fn explained_blueprint() -> PolicyCheck { - PolicyCheck::new(policy_of( + PolicyCheck::new(Arc::new( parse( r#" name: explained @@ -357,7 +648,7 @@ permissions: #[test] fn a_path_that_cannot_be_normalized_is_a_runtime_invariant_with_its_reason() { - let policy = PolicyCheck::new(policy_of(parse("name: open\ndefault: allow\n").unwrap())); + let policy = PolicyCheck::new(Arc::new(parse("name: open\ndefault: allow\n").unwrap())); let context = serde_json::json!({"path": "/a\u{0}b"}); // Enforcement is what it was: a denial with no rule, which reads as a default deny // to the server's audit and keeps doing so. @@ -387,6 +678,26 @@ permissions: )); } + #[test] + fn normalized_policy_paths_are_vfs_path_fields_in_the_catalog() { + use interpreter::stdlib::capabilities::{FieldNormalization, catalog}; + for capability in catalog().iter().flat_map(|group| group.capabilities) { + for field in filesystem_path_fields(capability.name) { + let normalization = capability + .filter_fields + .iter() + .find(|candidate| candidate.name == *field) + .map(|candidate| candidate.normalization); + assert_eq!( + normalization, + Some(FieldNormalization::VfsPath), + "{}.{field}", + capability.name + ); + } + } + } + #[test] fn filesystem_policy_matches_normalized_guest_paths() { let blueprint = parse( @@ -427,7 +738,7 @@ permissions: ) .unwrap(); let policy = PolicyCheck::with_variables( - policy_of(blueprint), + Arc::new(blueprint), Arc::new(BTreeMap::from([("user".into(), "ada".into())])), ); for capability in [ @@ -510,7 +821,7 @@ permissions: #[test] fn filesystem_denials_name_the_normalized_path() { - let policy = PolicyCheck::new(policy_of( + let policy = PolicyCheck::new(Arc::new( parse( r#" name: closed @@ -556,7 +867,7 @@ permissions: #[test] fn filesystem_policy_blocklists_use_the_resolved_path() { - let policy = PolicyCheck::new(policy_of( + let policy = PolicyCheck::new(Arc::new( parse( r#" name: blocked diff --git a/crates/submilli/src/commands/run.rs b/crates/submilli/src/commands/run.rs index 30fbde746..a72f0f75d 100644 --- a/crates/submilli/src/commands/run.rs +++ b/crates/submilli/src/commands/run.rs @@ -501,10 +501,7 @@ fn execute_on_this_thread( data.install_type_info(compiled.type_info.clone()); if let Some(bp) = &blueprint { data.git = submilli_shared::resolve_git(bp, &variables)?; - data.security_check = Arc::new(PolicyCheck::with_variables( - Arc::new(bp.policy()), - variables, - )); + data.security_check = Arc::new(PolicyCheck::with_variables(bp.clone(), variables)); data.auth_proxy = Arc::new(BlueprintAuthProxy::new(bp.clone(), secret_store.clone())); data.secret_provider = Arc::new(BlueprintSecretProvider::new( bp.clone(),