# 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
nbt_chest_build = FFI SNBT builder for chests (Python/JS use chest() helper directly)
nbt_sign_build = FFI SNBT builder for signs (Python/JS use sign() helper directly)
nbt_text_build = FFI SNBT builder for text components (Python/JS use text() helper)
Schematic.simulate_use_block = FFI one-shot simulate convenience (Python uses simulate(events=); WASM exposes a separate simulation world API)
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]
Schematic.block_simple = Python strict-signature fast variant (4 i32 + str) for tight loops; WASM/FFI use the polished set_block which already covers this case
Schematic.blocks_flat = Python flat-array variant of set_blocks accepting [x0,y0,z0,...]; WASM uses &[i32] natively, FFI takes pointer + length
*.__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
ResourcePack.from_files = Python file I/O (WASM has no filesystem, FFI uses byte buffers)
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]
Shape.union_shapes = WASM naming (Rust fn union_shapes with js_name=union, Python uses union)
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]
Shape.union = Python/FFI naming (WASM uses union_shapes with js_name=union)
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]
Shape.union_shapes = WASM naming (Python uses union)
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]
Shape.union_shapes = WASM naming (FFI uses shape_union)
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

# --- Item Model exclusions ---
# ItemModelConfig/Result: naming differences across platforms
[python_only]
ItemModelResult.save_resource_pack = Python file I/O convenience
ItemModelResult.save_model_json = Python file I/O convenience
ItemModelResult.get_all_textures = Python convenience method
py_build_resource_pack = Python naming (WASM uses buildResourcePack, FFI uses itemmodel_build_resource_pack)

[wasm_only]
build_resource_pack_wasm = WASM naming (Python uses build_resource_pack, FFI uses itemmodel_build_resource_pack)
ItemModelResult.get_texture = WASM typed array return format

[no_wasm]
ItemModelResult.save_resource_pack = No filesystem in WASM
ItemModelResult.save_model_json = No filesystem in WASM
ItemModelResult.get_all_textures = Python convenience (WASM uses getTexture per-name)

[no_ffi]
ItemModelConfig.* = FFI uses itemmodel_config_* free functions
ItemModelResult.* = FFI uses itemmodel_result_* free functions

[ffi_only]
itemmodel_* = FFI free functions for ItemModel (WASM/Python use wrapper methods)

# --- 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)
renderconfig_* = FFI free functions for RenderConfig (WASM/Python use wrapper methods)
render_pixels_free = FFI memory management

# --- Rendering exclusions ---
[wasm_only]
Schematic.render_wasm = WASM naming (Python uses render, FFI uses schematic_render)
Schematic.render_png_wasm = WASM naming (Python uses render_png, FFI uses schematic_render_png)

[no_wasm]
Schematic.render = Python/FFI naming (WASM uses render_wasm with js_name=render)
Schematic.render_png = Python/FFI naming (WASM uses render_png_wasm with js_name=renderPng)
Schematic.render_to_file = No filesystem in WASM
RenderConfig.fov = WASM uses setFov/getter pattern (different naming)
RenderConfig.projection = Python exposes a Projection enum (projection getter); WASM uses an orthographic bool (setOrthographic/orthographic)

[python_only]
RenderConfig.__repr__ = Python dunder method

[no_python]
Schematic.render_wasm = WASM naming (Python uses render)
Schematic.render_png_wasm = WASM naming (Python uses render_png)
RenderConfig.orthographic = WASM bool API (setOrthographic/orthographic); Python uses the Projection enum (projection)

[no_ffi]
RenderConfig.* = FFI uses renderconfig_* free functions not methods on wrapper type
Schematic.render_wasm = WASM naming (FFI uses schematic_render)
Schematic.render_png_wasm = WASM naming (FFI uses schematic_render_png)

# --- Diff + Fingerprint engines ---
# FFI exposes the Diff type as diff_* free functions (mapped to the Diff class via
# the known-prefix table); WASM/Python expose it as a wrapper object. The entries
# below are genuine, intended idiom divergences.
[ffi_only]
Schematic.diff_opts = FFI override variant (WASM/Python pass an options arg to diff())
*.free_glb = FFI memory management for returned GLB buffers

[python_only]
Diff.transform_json = Python convenience (transform is also inside to_json; WASM/FFI read it there)

[no_ffi]
Diff.regions_json = Python/WASM convenience (FFI consumers read regions from summary_json)

# --- Store + transparent I/O ---
# The Store byte-backend is exposed in all three; constructor naming and memory
# management differ by idiom. Schematic.open/open_from_store/save_to_store are
# transparent-I/O sugar: FFI exposes them natively, WASM has openFromStore (no
# filesystem), and Python implements them in the pure-Python facade
# (nucleation/__init__.py), which the Rust-parsing checker can't see.
[ffi_only]
Store.bytes_free = FFI memory management for returned byte buffers
Store.string_free = FFI memory management for returned strings
Store.last_error = FFI thread-local error string (WASM/Python raise exceptions)

[wasm_only]
Store.new = WASM JS constructor (`new Store(url)`); Python/FFI use Store.open(url)

[no_ffi]
Store.from_callbacks = host-closure store (Py/JS callables); FFI users pass a backend URL to nuc_store_open

[no_wasm]
Schematic.open = No filesystem in WASM; use openFromStore(store, key)

[no_python]
Schematic.open = Python provides this in the pure-Python facade (nucleation/__init__.py Schematic.open)
Schematic.open_from_store = Python facade folds this into Schematic.open(store, key)
Schematic.save_to_store = Python facade folds this into Schematic.save(store, key)
