# API Parity Exclusions
# Format:
#   [section] - One of: wasm_only, python_only, ffi_only, no_ffi, no_wasm, no_python
#   Class.method = reason   (class-scoped exclusion)
#   free_function = reason  (free function exclusion)
#   *.method = reason       (wildcard class)
#   Class.prefix* = reason  (prefix match)
#
# [wasm_only]   = expected in WASM only -> suppress if missing from Python/FFI
# [python_only] = expected in Python only -> suppress if missing from WASM/FFI
# [ffi_only]    = expected in FFI only -> suppress if missing from WASM/Python
# [no_ffi]      = not expected in FFI -> suppress if missing from FFI
# [no_wasm]     = not expected in WASM -> suppress if missing from WASM
# [no_python]   = not expected in Python -> suppress if missing from Python

[ffi_only]
*.free = FFI memory management
free_* = FFI memory management
MchprsWorld.new_with_custom_io = FFI constructor variant with custom IO positions
MchprsWorld.new_with_options = FFI constructor variant (WASM/Python use with_options)
Value.as_* = FFI value type accessors (WASM uses to_js, Python uses to_py)
Value.type_name = FFI value type introspection (WASM/Python use language-native type checks)
Schematic.print = FFI debug variant (WASM/Python use print_schematic)
Schematic.save_to_file = FFI file I/O convenience (Python uses save, WASM has no filesystem)
SchematicBuilder.build_with_error = FFI error-via-outpointer pattern (WASM/Python use exceptions)

[python_only]
*.__repr__ = Python dunder method
*.__str__ = Python dunder method
*.__bool__ = Python dunder method
*.__len__ = Python dunder method
*.__copy__ = Python dunder method
*.__deepcopy__ = Python dunder method
load_schematic = Python file I/O convenience
save_schematic = Python file I/O convenience
Schematic.test = Python debug method
Schematic.cache_info = Python debug method
Schematic.clear_cache = Python debug method
Schematic.save = Python file I/O convenience (WASM has no filesystem, FFI uses save_to_file)
ResourcePack.from_file = Python file I/O
MeshResult.save = Python file I/O
MultiMeshResult.save_all = Python file I/O
ChunkMeshResult.save_all = Python file I/O
Value.to_py = Python interop
Value.bool = Python factory naming (FFI uses value_from_bool)
Value.f32 = Python factory naming (FFI uses value_from_f32)
Value.i32 = Python factory naming (FFI uses value_from_i32)
Value.string = Python factory naming (FFI uses value_from_string)
Value.u32 = Python factory naming (FFI uses value_from_u32)

[wasm_only]
start = WASM panic hook init
LazyChunkIterator.* = WASM-specific lazy iteration
Schematic.blocks_indices = WASM JS optimization
Schematic.chunks_indices = WASM JS optimization
Schematic.chunks_indices_with_strategy = WASM JS optimization
Schematic.get_chunk_blocks_indices = WASM JS optimization
Schematic.get_chunk_data = WASM JS optimization
Schematic.get_optimization_info = WASM debug
Schematic.optimization_info = WASM debug
Schematic.create_lazy_chunk_iterator = WASM-specific lazy iteration
Schematic.blocks = WASM JS array return format
PaletteManager.* = WASM-specific palette helper
StateModeConstants.* = WASM-specific constants enum
SimulationOptions.* = WASM-specific simulation config
Value.to_js = WASM JS interop
Value.from_* = WASM factory methods
ResourcePack.get_stats = WASM debug
ResourcePack.stats = WASM debug
MeshResult.get_stats = WASM debug
MeshResult.stats = WASM debug
CircuitBuilder.with_options = WASM-specific (uses SimulationOptions type)
IoLayoutBuilder.add_input_region = WASM-specific (takes min/max coords directly)
IoLayoutBuilder.add_input_region_auto = WASM-specific (takes min/max coords directly)
IoLayoutBuilder.add_output_region = WASM-specific (takes min/max coords directly)
IoLayoutBuilder.add_output_region_auto = WASM-specific (takes min/max coords directly)
TypedCircuitExecutor.from_insign_with_options = WASM-specific (uses SimulationOptions)
TypedCircuitExecutor.from_layout_with_options = WASM-specific (uses SimulationOptions)
TypedCircuitExecutor.run = WASM-specific simplified execute
TypedCircuitExecutor.sync_to_schematic = WASM-specific sync API
MchprsWorld.with_options = WASM-specific (uses SimulationOptions type)
MchprsWorld.truth_table = WASM-specific truth table generation

# --- Methods not expected in WASM ---
[no_wasm]
Schematic.from_world_directory = Filesystem not available in WASM
Schematic.from_world_directory_bounded = Filesystem not available in WASM
Schematic.save_world = Filesystem not available in WASM
Schematic.from_file = Filesystem not available in WASM
Schematic.save = Filesystem not available in WASM
Schematic.save_to_file = Filesystem not available in WASM
Schematic.all_blocks = FFI/Python naming convention (WASM uses blocks())
# RawMeshExport: FFI short names not in WASM (WASM uses _flat suffix)
RawMeshExport.positions = FFI naming (WASM: positions_flat)
RawMeshExport.normals = FFI naming (WASM: normals_flat)
RawMeshExport.uvs = FFI naming (WASM: uvs_flat)
RawMeshExport.colors = FFI naming (WASM: colors_flat)
DefinitionRegion.set_metadata_mut = Python mutability helper (WASM uses set_metadata)
DefinitionRegion.sync = FFI sync method (WASM uses direct property access)
ResourcePack.from_bytes = Python/FFI binary I/O
MultiMeshResult.all_meshes = Python convenience method
ChunkMeshResult.all_meshes = Python convenience method
Value.bool = Python typed value factory
Value.f32 = Python typed value factory
Value.i32 = Python typed value factory
Value.u32 = Python typed value factory
Value.string = Python typed value factory

# --- Methods not expected in Python ---
[no_python]
Schematic.chunk_blocks = WASM/FFI chunk access (Python has different iteration)
# RawMeshExport: FFI short names not in Python (Python uses _flat suffix)
RawMeshExport.positions = FFI naming (Python: positions_flat)
RawMeshExport.normals = FFI naming (Python: normals_flat)
RawMeshExport.uvs = FFI naming (Python: uvs_flat)
RawMeshExport.colors = FFI naming (Python: colors_flat)
Schematic.chunks_with_strategy = WASM/FFI chunk loading strategies
Schematic.save_to_file = FFI naming (Python uses save)
ResourcePack.new = WASM constructor (Python uses from_file/from_bytes)
MchprsWorld.new = WASM constructor (Python creates via Schematic method)
Schematic.create_simulation_world_with_options = WASM-specific (uses SimulationOptions)
Schematic.create_circuit = WASM/FFI convenience (Python uses CircuitBuilder directly)
Schematic.create_circuit_builder = WASM/FFI convenience (Python uses CircuitBuilder directly)
DefinitionRegion.blocks = WASM/FFI method (returns blocks at positions)
DefinitionRegion.clone_region = WASM/FFI alias for copy

# --- Methods not expected in FFI ---
[no_ffi]
Schematic.create_circuit = Requires circuit ecosystem convenience on Schematic
Schematic.create_circuit_builder = Requires circuit ecosystem convenience on Schematic
Schematic.build_executor = Requires circuit ecosystem convenience on Schematic
Schematic.create_simulation_world = Simulation convenience on Schematic
Schematic.create_simulation_world_with_options = Simulation convenience on Schematic
MchprsWorld.into_schematic = FFI uses get_schematic + sync_to_schematic (cannot consume pointer)
Schematic.save = Python naming (FFI uses save_to_file)

# --- Meshing ecosystem: specific exclusions ---
# RawMeshExport: Python/WASM _flat suffix not in FFI (FFI: rawmeshexport_positions etc.)
RawMeshExport.positions_flat = Python/WASM naming (FFI: positions)
RawMeshExport.normals_flat = Python/WASM naming (FFI: normals)
RawMeshExport.uvs_flat = Python/WASM naming (FFI: uvs)
RawMeshExport.colors_flat = Python/WASM naming (FFI: colors)
ResourcePack.new = WASM constructor (FFI uses from_bytes)
ResourcePack.stats = FFI exposes individual stat getters
MultiMeshResult.all_meshes = Python convenience (FFI uses get_mesh)
ChunkMeshResult.all_meshes = Python convenience (FFI uses get_mesh)
MeshExporter.* = Mesh exporter registered via FormatManager (FFI uses schematic_register_mesh_exporter)

# --- Global atlas / progress API differences ---
# TextureAtlas: FFI uses free functions, WASM/Python use wrapper object methods
[ffi_only]
textureatlas_* = FFI free functions for TextureAtlas (WASM/Python use wrapper methods)
Schematic.mesh_chunks_with_atlas_progress = FFI C-callback progress variant (WASM uses setProgressCallback on iterator)
ChunkMeshResult.nucm_data_with_atlas = FFI separate atlas-aware NUCM export (WASM/Python handle internally)

[wasm_only]
ChunkMeshIterator.* = WASM-specific lazy iterator with atlas/progress (Python/FFI use eager methods)

[no_python]
Schematic.chunk_mesh_iterator = WASM-specific lazy iterator (Python uses mesh_chunks)
Schematic.chunk_mesh_iterator_with_atlas = WASM-specific lazy iterator with atlas (Python uses mesh_chunks_with_atlas)
Schematic.mesh_chunks_with_atlas_progress = FFI C-callback pattern (Python doesn't need separate progress variant)
TextureAtlas.to_bytes = WASM naming (Python uses rgba_data)
ChunkMeshResult.to_nucm = WASM naming (Python uses nucm_data/save_nucm)
ChunkMeshResult.nucm_data_with_atlas = FFI-specific atlas-aware NUCM export

[no_wasm]
Schematic.mesh_chunks = Python/FFI eager chunked meshing (WASM uses chunkMeshIterator)
Schematic.mesh_chunks_with_atlas = Python/FFI eager chunked meshing with atlas (WASM uses chunkMeshIteratorWithAtlas)
TextureAtlas.region_count = Python convenience property
TextureAtlas.rgba_data = Python naming (WASM uses toBytes)
ChunkMeshResult.nucm_data = Python/FFI naming (WASM uses toNucm)
ChunkMeshResult.nucm_data_with_atlas = FFI-specific atlas-aware NUCM export
ChunkMeshResult.save_nucm = Python file I/O (no filesystem in WASM)

[no_ffi]
Schematic.chunk_mesh_iterator = WASM lazy iterator (FFI uses eager schematic_mesh_chunks)
Schematic.chunk_mesh_iterator_with_atlas = WASM lazy iterator with atlas (FFI uses eager variant)
Schematic.mesh_chunks = Python eager chunked meshing (FFI uses schematic_mesh_by_chunk_size)
TextureAtlas.* = FFI uses free functions (textureatlas_*) not methods on a wrapper type
ChunkMeshResult.to_nucm = WASM naming (FFI uses chunkmeshresult_nucm_data)
ChunkMeshResult.save_nucm = Python file I/O (FFI does not provide file I/O)

# --- MeshOutput / MeshResult naming divergence ---
# WASM wraps single-mesh results as MeshOutput; Python wraps them as MeshResult.
# FFI exposes a subset via meshresult_* free functions.
# These are the same concept with different wrapper names, not missing implementations.

[wasm_only]
MeshOutput.* = WASM single-mesh wrapper (Python uses MeshResult, FFI uses meshresult_*)

[no_wasm]
MeshResult.* = Python single-mesh wrapper (WASM uses MeshOutput)
MultiMeshResult.nucm_data = Python naming (WASM uses toNucm on iterator)
MultiMeshResult.save_nucm = Python file I/O (no filesystem in WASM)

[no_ffi]
MeshOutput.* = WASM wrapper type (FFI uses meshresult_* free functions)
MeshResult.atlas_height = Python wrapper accessor (FFI uses meshresult_* subset)
MeshResult.atlas_rgba = Python wrapper accessor
MeshResult.atlas_width = Python wrapper accessor
MeshResult.chunk_coord = Python wrapper accessor
MeshResult.cutout_indices = Python wrapper accessor
MeshResult.cutout_positions = Python wrapper accessor
MeshResult.is_empty = Python wrapper accessor
MeshResult.lod_level = Python wrapper accessor
MeshResult.opaque_colors = Python wrapper accessor
MeshResult.opaque_indices = Python wrapper accessor
MeshResult.opaque_normals = Python wrapper accessor
MeshResult.opaque_positions = Python wrapper accessor
MeshResult.opaque_uvs = Python wrapper accessor
MeshResult.save_nucm = Python file I/O
MeshResult.total_triangles = Python wrapper accessor
MeshResult.total_vertices = Python wrapper accessor
MeshResult.transparent_indices = Python wrapper accessor
MeshResult.transparent_positions = Python wrapper accessor
MeshResult.usdz_data = Python wrapper accessor
MultiMeshResult.nucm_data = Python naming (FFI uses chunkmeshresult_nucm_data)
MultiMeshResult.save_nucm = Python file I/O

# --- Scripting FFI entry points (feature-gated, not in WASM/Python) ---
[ffi_only]
run_lua_script = FFI scripting entry point (feature-gated scripting-lua)
run_js_script = FFI scripting entry point (feature-gated scripting-js)
run_script = FFI scripting entry point (feature-gated scripting)
Schematic.last_error = FFI error handling via thread-local (WASM/Python use exceptions)
