oak-editor/crates/oakengine/tests/it_node.rs

// Oak Video Editor - Non-Linear Video Editor
// Copyright (C) 2026 Oak Team
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

//! Integration tests for the node family: every `oakengine_*` export of
//! the facade's node module (src/node.rs; module C contract
//! `include/node/{node,project,footage,keyframe,dragger,group,multicam,...}.h`),
//! exercised end to end against the REAL `oaknode` crate — no mocks.
//!
//! Coverage contract (see the sibling it_plugin.rs):
//! - every export is called on a legal path with the result asserted;
//! - value-range inputs (indices, type ordinals, sizes, track counts) get
//!   the meaningful combinations;
//! - illegal inputs (NULL / empty `CHandle` boxes, out-of-range indices,
//!   zero/negative sizes, garbage enum ordinals) return a clean negative
//!   code or the documented no-op — never a crash;
//! - destroy contracts: facade `free`/`dispose` are NULL/empty no-ops, and
//!   the module destroy paths they delegate to are double-free-safe;
//! - the family's debug alive counter (`oaknode_debug_alive_count`) returns
//!   to baseline after every owned-object round trip.
//!
//! The facade owns a process-wide undo stack, so every test that pushes
//! undoable commands (or asserts undo state) runs inside [`with_owned`],
//! the same global mutex that guards the alive-counter assertions (owned
//! objects are the only ALIVE sources). Tests that only touch borrowed
//! handles or static helpers run in parallel.
//!
//! The node family is 327 exports. The facade divergences found while
//! exercising the family (documented in the block below the tests) are all
//! fixed in src/node.rs and asserted as correct behavior here.

#[path = "common/mod.rs"]
mod common;

use std::ffi::{c_char, c_int, c_void, CStr, CString};
use std::sync::Mutex;

use oakengine::common::OakVideoParamsPod;
use oakengine::handle::{
	CHandle, OakEngineFootage, OakEngineKeyframe, OakEngineNode, OakEngineNodeDragger,
	OakEngineProject,
};
use oakengine::node::value_type as vt;
use oakengine::node::*;
use oakengine::timeline::oakengine_clip_as_node;
use oakengine::undo::oakengine_undo_command_free;
use oaknode::ffi::dragger::oaknode_dragger_free;
use oaknode::ffi::factory::oaknode_factory_create_from_id;
use oaknode::ffi::keyframe::oaknode_keyframe_create as oaknode_kf_create;
use oaknode::ffi::keyframe::oaknode_keyframe_free;
use oaknode::ffi::node::oaknode_debug_alive_count;
use oaknode::ffi::node::oaknode_node_free;
use oaknode::ffi::project::oaknode_project_free;

/// Facade error codes (src/error.rs).
const E_INVALID: c_int = -1;
const E_STATE: c_int = -2;
const E_FAILED: c_int = -3;
const E_NOT_FOUND: c_int = -4;
/// Module error codes (include/node/error.h) — passed through untranslated.
const NODE_E_INVALID: c_int = -30001;
const NODE_E_STATE: c_int = -30002;
const NODE_E_NOT_FOUND: c_int = -30004;

/// Registered node type ids used by the tests (NUL-terminated `&CStr` so
/// `.as_ptr()` is a valid C string, matching the engine's `c"..."` usage).
const TYPE_VALUE: &std::ffi::CStr = c"org.olivevideoeditor.Olive.value";
const TYPE_SOLID: &std::ffi::CStr = c"org.olivevideoeditor.Olive.solidgenerator";
const TYPE_TRANSFORM: &std::ffi::CStr = c"org.olivevideoeditor.Olive.transform";
const TYPE_TEXT: &std::ffi::CStr = c"org.olivevideoeditor.Olive.textgenerator";
const TYPE_GROUP: &std::ffi::CStr = c"org.olivevideoeditor.Olive.group";
const TYPE_MULTICAM: &std::ffi::CStr = c"org.olivevideoeditor.Olive.multicam";
const TYPE_FOOTAGE: &std::ffi::CStr = c"org.olivevideoeditor.Olive.footage";
const TYPE_BLUR: &std::ffi::CStr = c"org.olivevideoeditor.Olive.blur";
const TYPE_OPACITY: &std::ffi::CStr = c"org.olivevideoeditor.Olive.opacity";

// ---------------------------------------------------------------------------
// Fixtures
// ---------------------------------------------------------------------------

/// Serialize the owned-object / undo-stack tests: the alive counter and
/// the process-wide undo stack are shared across tests in this binary, so
/// every test that creates owned objects or pushes commands holds the same
/// mutex. Tests that only use borrowed handles run unguarded.
fn with_owned(f: impl FnOnce()) {
	static LOCK: Mutex<()> = Mutex::new(());
	let _g = LOCK.lock().unwrap_or_else(|e| e.into_inner());
	f();
}

/// Live owned objects (projects, factory/group/copy nodes).
fn alive() -> c_int {
	unsafe { oaknode_debug_alive_count() }
}

/// Read a two-stage facade string out of a fixed buffer.
unsafe fn read_buf(buf: &[c_char]) -> String {
	if buf.first().copied().unwrap_or(0) == 0 {
		String::new()
	} else {
		CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
	}
}

/// Read a NUL-terminated C string.
unsafe fn read_cstr(s: *const c_char) -> String {
	unsafe { CStr::from_ptr(s).to_string_lossy().into_owned() }
}

/// A float POD value.
fn float_value(x: f64) -> OakNodeValue {
	OakNodeValue {
		kind: vt::FLOAT,
		num: 0,
		den: 0,
		f: [x, 0.0, 0.0, 0.0],
	}
}

/// A float POD value of the DIRECTLY imported oaknode instance. Under
/// `cargo test --workspace` oaknode is built twice (oaknode's own
/// dev-dependency enables oakcodec/test-stubs, splitting the build
/// units), so `oakengine::node::OakNodeValue` and
/// `oaknode::value::OakNodeValue` are distinct types there; the direct
/// `oaknode_ffi` calls below need this one.
fn float_value_direct(x: f64) -> oaknode::value::OakNodeValue {
	oaknode::value::OakNodeValue {
		kind: oaknode::value::oak::FLOAT,
		num: 0,
		den: 0,
		f: [x, 0.0, 0.0, 0.0],
	}
}

/// An int (combo-compatible) POD value.
fn int_value(x: i64) -> OakNodeValue {
	OakNodeValue {
		kind: vt::INT,
		num: x,
		den: 0,
		f: [0.0; 4],
	}
}

/// A vec2 POD value.
fn vec2_value(x: f64, y: f64) -> OakNodeValue {
	OakNodeValue {
		kind: vt::VEC2,
		num: 0,
		den: 0,
		f: [x, y, 0.0, 0.0],
	}
}

/// A fresh project box (owned; caller frees with `oakengine_project_free`).
fn new_project() -> *mut OakEngineProject {
	let p = oakengine_project_create();
	assert!(!p.is_null());
	assert_eq!(unsafe { oakengine_project_new(p) }, 0);
	p
}

/// A box wrapping an empty (null-ctx) node handle — the "invalid handle"
/// class distinct from a NULL pointer.
fn empty_node_box() -> *mut OakEngineNode {
	Box::into_raw(Box::new(OakEngineNode {
		handle: CHandle::null(),
	}))
}

/// A live box holding an addref'd copy of `node`'s handle, to hand to
/// `oakengine_node_group_get_inner` (that export replaces the box with the
/// resolved node; the replaced shell is leaked by design of the API). The
/// copy is addref'd so freeing this shell and the original handle later
/// both release their own reference (no double-free).
unsafe fn group_inner_slot(node: *mut OakEngineNode) -> *mut OakEngineNode {
	let mut handle = unsafe { (*node).handle };
	if let Some(addref) = handle.addref {
		unsafe { addref(handle.ctx) };
	}
	Box::into_raw(Box::new(OakEngineNode { handle }))
}

/// Fresh file under the system temp dir with a unique name.
fn fresh_temp_file(name: &str, contents: &[u8]) -> std::path::PathBuf {
	let p = std::env::temp_dir().join(format!("oak-it-node-{}-{name}", std::process::id()));
	std::fs::write(&p, contents).expect("write temp file");
	p
}

/// The index of the first project node whose type id matches `id`, or -1.
unsafe fn find_node(project: *mut OakEngineProject, id: &str) -> c_int {
	let count = oakengine_project_node_count(project);
	for i in 0..count {
		let node = oakengine_project_node_at(project, i);
		if node.is_null() {
			continue;
		}
		let mut buf = [0 as c_char; 256];
		let len = oakengine_node_get_type_id(node, buf.as_mut_ptr(), 256);
		if len > 0 && unsafe { read_buf(&mut buf) } == id {
			return i;
		}
	}
	-1
}

/// Force the oakundo command / oakcommon xml dlsym targets into the link
/// (the oaknode serializer bridge resolves them at runtime; same helper as
/// the sibling tests/node.rs).
fn force_oakundo_command_link() -> usize {
	let fns: [usize; 3] = [
		oakundo::ffi::command::oakundo_command_init as *const () as usize,
		oakcommon::ffi::xmlutils::oakcommon_xml_writer_init as *const () as usize,
		oakcommon::ffi::xmlutils::oakcommon_xml_reader_init as *const () as usize,
	];
	fns.iter().sum()
}

// ---------------------------------------------------------------------------
// Static helpers and pure functions (no handles; parallel-safe)
// ---------------------------------------------------------------------------

/// Static node ids, category names, value-type names and value math.
#[test]
fn static_ids_and_pure_helpers() {
	common::force_link();
	let _ = force_oakundo_command_link();

	// Static input-id strings.
	assert_eq!(
		unsafe { read_cstr(oakengine_folder_child_input_key()) },
		"child_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_node_enabled_input_id()) },
		"enabled_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_volume_samples_input_id()) },
		"samples_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_transform_texture_input_id()) },
		"tex_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_transition_in_block_input_id()) },
		"in_block_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_transition_out_block_input_id()) },
		"out_block_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_subtitle_text_input_id()) },
		"text_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_project_item_mime_type()) },
		"application/x-oliveprojectitemdata"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_multicam_input_current()) },
		"current_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_multicam_input_sources()) },
		"sources_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_multicam_input_sequence()) },
		"sequence_in"
	);
	assert_eq!(
		unsafe { read_cstr(oakengine_multicam_input_sequence_type()) },
		"sequence_type_in"
	);

	// Static flags.
	assert_eq!(oakengine_node_flag_dont_show_in_param_view(), 0x1);
	assert_eq!(oakengine_node_flag_video_effect(), 0x2);
	assert_eq!(oakengine_node_flag_audio_effect(), 0x4);
	assert_eq!(oakengine_node_flag_dont_show_in_create_menu(), 0x8);

	// Static scalars.
	assert_eq!(oakengine_audio_waveform_max_sample_rate(), 1024.0);
	assert_eq!(oakengine_keyframe_default_type(), 0);
	assert_eq!(oakengine_keyframe_opposing_bezier_type(0), 1);
	assert_eq!(oakengine_keyframe_opposing_bezier_type(1), 0);
	// Garbage type ordinal → module INVALID, never a crash.
	assert_eq!(oakengine_keyframe_opposing_bezier_type(2), NODE_E_INVALID);
	assert_eq!(oakengine_keyframe_opposing_bezier_type(-7), NODE_E_INVALID);

	// Category name matrix: 0..=11 named, everything else "Uncategorized".
	let mut buf = [0 as c_char; 64];
	for (cat, expected) in [
		(0, "Output"),
		(1, "Generator"),
		(2, "Math"),
		(3, "Keying"),
		(4, "Filter"),
		(5, "Color"),
		(6, "Time"),
		(7, "Timeline"),
		(8, "Transition"),
		(9, "Distort"),
		(10, "Project"),
		(11, "OpenFX"),
	] {
		let len = unsafe { oakengine_node_category_name(cat, buf.as_mut_ptr(), 64) };
		assert_eq!(len, expected.len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, expected);
	}
	assert_eq!(
		unsafe { oakengine_node_category_name(12, buf.as_mut_ptr(), 64) },
		13
	);
	assert_eq!(unsafe { read_buf(&mut buf) }, "Uncategorized");
	assert_eq!(
		unsafe { oakengine_node_category_name(-1, buf.as_mut_ptr(), 64) },
		13
	);
	assert_eq!(unsafe { read_buf(&mut buf) }, "Uncategorized");

	// Value keyframe track counts: 1 scalar, 2/3/4 vectors, 4 color, 6 bezier.
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::FLOAT), 1);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::INT), 1);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::VEC2), 2);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::VEC3), 3);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::VEC4), 4);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::COLOR), 4);
	assert_eq!(oakengine_node_value_keyframe_track_count(vt::BEZIER), 6);
	assert_eq!(oakengine_node_value_keyframe_track_count(999), 1);

	// Pretty type names for every legal ordinal.
	for ty in 1..=19 {
		let len = unsafe { oakengine_node_value_pretty_type_name(ty, buf.as_mut_ptr(), 64) };
		assert!(len > 0, "pretty type name for {ty} must not be empty");
	}
	// NONE (0), negative and > AUDIO_PARAMS are invalid.
	assert_eq!(
		unsafe { oakengine_node_value_pretty_type_name(0, buf.as_mut_ptr(), 64) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_value_pretty_type_name(-1, buf.as_mut_ptr(), 64) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_value_pretty_type_name(20, buf.as_mut_ptr(), 64) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_value_pretty_type_name(999, buf.as_mut_ptr(), 64) },
		E_INVALID
	);

	// split_to_tracks: vec2 → two per-component track values; combine back.
	let mut tracks = [unsafe { std::mem::zeroed::<OakNodeValue>() }; 2];
	assert_eq!(
		unsafe {
			oakengine_node_value_split_to_tracks(
				vt::VEC2,
				&vec2_value(1.0, 2.0),
				tracks.as_mut_ptr(),
				2,
			)
		},
		0
	);
	assert_eq!(tracks[0].kind, vt::VEC2);
	// Track `i` carries component `i`; combine reassembles them.
	assert!((tracks[0].f[0] - 1.0).abs() < 1e-9);
	assert!((tracks[1].f[0] - 2.0).abs() < 1e-9);
	let mut out = unsafe { std::mem::zeroed::<OakNodeValue>() };
	assert_eq!(
		unsafe { oakengine_node_value_combine_tracks(vt::VEC2, tracks.as_ptr(), 2, &mut out) },
		0
	);
	assert!((out.f[0] - 1.0).abs() < 1e-9);
	assert!((out.f[1] - 2.0).abs() < 1e-9);

	// split/combine of a float keeps a single track; track_count mismatch is
	// clamped by split and illegal (<= 0) for both.
	let mut ft = [unsafe { std::mem::zeroed::<OakNodeValue>() }; 4];
	assert_eq!(
		unsafe {
			oakengine_node_value_split_to_tracks(vt::FLOAT, &float_value(3.5), ft.as_mut_ptr(), 4)
		},
		0
	);
	assert!((ft[0].f[0] - 3.5).abs() < 1e-9);
	assert_eq!(
		unsafe {
			oakengine_node_value_split_to_tracks(
				vt::FLOAT,
				&float_value(1.0),
				std::ptr::null_mut(),
				1,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_value_split_to_tracks(vt::FLOAT, &float_value(1.0), ft.as_mut_ptr(), 0)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_value_split_to_tracks(vt::FLOAT, std::ptr::null(), ft.as_mut_ptr(), 1)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_value_combine_tracks(vt::FLOAT, ft.as_ptr(), 0, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_value_combine_tracks(vt::FLOAT, std::ptr::null(), 1, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_value_combine_tracks(vt::FLOAT, ft.as_ptr(), 1, std::ptr::null_mut())
		},
		E_INVALID
	);

	// Multicam grid math legal matrix + illegal inputs.
	let mut rows: c_int = 0;
	let mut cols: c_int = 0;
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(1, &mut rows, &mut cols) },
		0
	);
	assert_eq!((rows, cols), (1, 1));
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(4, &mut rows, &mut cols) },
		0
	);
	assert_eq!((rows, cols), (2, 2));
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(0, &mut rows, &mut cols) },
		0
	);
	assert_eq!((rows, cols), (1, 1));
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(-1, &mut rows, &mut cols) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(4, std::ptr::null_mut(), &mut cols) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_get_rows_and_columns(4, &mut rows, std::ptr::null_mut()) },
		E_INVALID
	);
	let mut r: c_int = 0;
	let mut c: c_int = 0;
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(0, 2, 2, &mut r, &mut c) },
		0
	);
	assert_eq!((r, c), (0, 0));
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(3, 2, 2, &mut r, &mut c) },
		0
	);
	assert_eq!((r, c), (1, 1));
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(-1, 2, 2, &mut r, &mut c) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(0, 0, 2, &mut r, &mut c) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(0, 2, 0, &mut r, &mut c) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(0, 2, 2, std::ptr::null_mut(), &mut c) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_index_to_row_cols(0, 2, 2, &mut r, std::ptr::null_mut()) },
		E_INVALID
	);
	assert_eq!(oakengine_multicam_rows_cols_to_index(1, 1, 2, 2), 3);
	assert_eq!(oakengine_multicam_rows_cols_to_index(0, 0, 2, 2), 0);
	assert_eq!(
		oakengine_multicam_rows_cols_to_index(-1, 0, 2, 2),
		E_INVALID
	);
	assert_eq!(
		oakengine_multicam_rows_cols_to_index(0, -1, 2, 2),
		E_INVALID
	);
	assert_eq!(oakengine_multicam_rows_cols_to_index(2, 0, 2, 2), E_INVALID);
	assert_eq!(oakengine_multicam_rows_cols_to_index(0, 2, 2, 2), E_INVALID);
	assert_eq!(oakengine_multicam_rows_cols_to_index(0, 0, 0, 2), E_INVALID);
	assert_eq!(oakengine_multicam_rows_cols_to_index(0, 0, 2, 0), E_INVALID);

	// Footage stream type names.
	for (t, name) in [
		(0, "Video"),
		(1, "Audio"),
		(2, "Subtitle"),
		(3, "Unknown"),
		(-1, "Unknown"),
	] {
		let len = unsafe { oakengine_footage_stream_type_name(t, buf.as_mut_ptr(), 64) };
		assert_eq!(len, name.len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, name);
	}
}

// ---------------------------------------------------------------------------
// Serialized legal paths (undo-stack mutating; owned objects)
// ---------------------------------------------------------------------------

/// Project lifecycle, factory, node metadata/params/graph edits, keyframes,
/// dragger, group, multicam, folder, bulk delete and footage — the full
/// legal matrix of the node family in one serialized test (the facade's
/// undo stack is process-wide, and owned-object creation feeds the alive
/// counter, both guarded by [`with_owned`]).
#[test]
fn node_family_legal_paths() {
	with_owned(|| {
		common::force_link();
		let _ = force_oakundo_command_link();
		let base = alive();
		let mut buf = [0 as c_char; 512];

		// ---- project shell: create → new → name/filename/cache --------
		let project = oakengine_project_create();
		assert!(!project.is_null());
		assert_eq!(alive(), base + 1, "an owned project must be alive-counted");

		// Freeing NULL is a no-op.
		unsafe { oakengine_project_free(std::ptr::null_mut()) };

		// A fresh project is untitled.
		let len = unsafe { oakengine_project_name(project, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "(untitled)".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "(untitled)");
		assert_eq!(
			unsafe { oakengine_project_filename(project, buf.as_mut_ptr(), 512) },
			0
		);

		// A second new on the same project is rejected with E_STATE.
		assert_eq!(unsafe { oakengine_project_new(project) }, 0);
		assert_eq!(unsafe { oakengine_project_new(project) }, E_STATE);

		// Modified flag round trip.
		assert_eq!(unsafe { oakengine_project_is_modified(project) }, 0);
		assert_eq!(unsafe { oakengine_project_set_modified(project, 1) }, 0);
		assert_eq!(unsafe { oakengine_project_is_modified(project) }, 1);
		assert_eq!(unsafe { oakengine_project_set_modified(project, 0) }, 0);
		assert_eq!(unsafe { oakengine_project_is_modified(project) }, 0);

		// Filename drives the display name.
		assert_eq!(
			unsafe { oakengine_project_set_filename(project, c"/tmp/oak_it_node.ovexml".as_ptr()) },
			0
		);
		let len = unsafe { oakengine_project_filename(project, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		assert!(unsafe { read_buf(&mut buf) }.ends_with("oak_it_node.ovexml"));
		let len = unsafe { oakengine_project_pretty_filename(project, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		let len = unsafe { oakengine_project_name(project, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "oak_it_node".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "oak_it_node");

		// Cache path surfaces.
		let rc = unsafe { oakengine_project_cache_path(project, buf.as_mut_ptr(), 512) };
		assert!(rc >= 0);
		assert_eq!(
			unsafe { oakengine_project_get_cache_location_setting(project) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_get_custom_cache_path(project, buf.as_mut_ptr(), 512) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_project_set_custom_cache_path(project, c"/tmp/oak_it_cache".as_ptr())
			},
			0
		);
		let len =
			unsafe { oakengine_project_get_custom_cache_path(project, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		assert_eq!(unsafe { read_buf(&mut buf) }, "/tmp/oak_it_cache");
		// NULL path clears the custom cache path.
		assert_eq!(
			unsafe { oakengine_project_set_custom_cache_path(project, std::ptr::null()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_get_custom_cache_path(project, buf.as_mut_ptr(), 512) },
			0
		);
		// Alongside path is a documented stub returning an empty string.
		assert_eq!(
			unsafe { oakengine_project_cache_alongside_path(project, buf.as_mut_ptr(), 512) },
			0
		);

		// Color reference space is a documented stub ("" / OK).
		assert_eq!(
			unsafe { oakengine_project_get_color_reference_space(project, buf.as_mut_ptr(), 512) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_set_color_reference_space(project, c"rec709".as_ptr()) },
			0
		);

		// Sequence enumeration: a fresh project has none.
		assert_eq!(unsafe { oakengine_project_sequence_count(project) }, 0);
		assert!(unsafe { oakengine_project_sequence_at(project, 0) }.is_null());

		// Root folder + node enumeration.
		assert_eq!(unsafe { oakengine_project_node_count(project) }, 1);
		let root = unsafe { oakengine_project_root(project) };
		assert!(!root.is_null());
		assert_eq!(unsafe { oakengine_node_is_folder(root) }, 1);
		assert_eq!(unsafe { oakengine_node_is_item(root) }, 1);
		assert_eq!(
			unsafe { oakengine_project_node_at(project, 0) }.is_null(),
			false
		);
		assert!(unsafe { oakengine_project_node_at(project, 999) }.is_null());
		unsafe { oakengine_node_free(root) }; // borrowed shell

		// ---- factory ----------------------------------------------------
		let factory_count = oakengine_node_factory_id_count();
		assert!(factory_count > 0);
		let proto = unsafe { oakengine_node_factory_node_at(0) };
		assert!(!proto.is_null());
		let len = unsafe { oakengine_node_get_type_id(proto, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		let type_id = unsafe { read_buf(&mut buf) };
		let type_id_c = CString::new(type_id.as_str()).unwrap();
		let name_len = unsafe {
			oakengine_node_factory_name_from_id(type_id_c.as_ptr(), buf.as_mut_ptr(), 512)
		};
		assert!(
			name_len > 0,
			"factory name for a registered id must resolve"
		);
		// Factory node index bounds.
		assert!(unsafe { oakengine_node_factory_node_at(-1) }.is_null());
		assert!(unsafe { oakengine_node_factory_node_at(1_000_000) }.is_null());
		// NULL type id → empty name (length 0), NULL → NULL node.
		assert_eq!(
			unsafe { oakengine_node_factory_name_from_id(std::ptr::null(), buf.as_mut_ptr(), 512) },
			0
		);
		assert!(unsafe { oakengine_node_factory_create_from_id(std::ptr::null()) }.is_null());
		// Unknown type id → NULL + a non-empty last error.
		assert!(
			unsafe { oakengine_node_factory_create_from_id(c"org.oak.no.such.node".as_ptr()) }
				.is_null()
		);
		let err_len = unsafe { oakengine_node_last_error(buf.as_mut_ptr(), 512) };
		assert!(
			err_len > 0,
			"node_last_error must be non-empty after a failed factory lookup"
		);
		unsafe { oakengine_node_free(proto) }; // borrowed prototype shell

		// Category / description / flags surfaces are stubs with stable results.
		let orphan = unsafe { oakengine_node_factory_create_from_id(TYPE_VALUE.as_ptr()) };
		assert!(!orphan.is_null());
		assert_eq!(
			alive(),
			base + 2,
			"an owned factory node must be alive-counted"
		);
		assert_eq!(unsafe { oakengine_node_category_count(orphan) }, 0);
		assert_eq!(unsafe { oakengine_node_category_at(orphan, 0) }, -1);
		assert_eq!(unsafe { oakengine_node_get_flags(orphan) }, 0);
		assert_eq!(
			unsafe { oakengine_node_get_sub_category(orphan, buf.as_mut_ptr(), 512) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_get_description(orphan, buf.as_mut_ptr(), 512) },
			0
		);
		unsafe { oakengine_node_retranslate(orphan) }; // void no-op
		unsafe { oakengine_node_delete_later(orphan) }; // void no-op
		unsafe { oakengine_node_get_brush(orphan, 0.0, 1.0, std::ptr::null_mut()) }; // void no-op

		// ---- metadata: type id / name / short name / label --------------
		let len = unsafe { oakengine_node_get_type_id(orphan, buf.as_mut_ptr(), 512) };
		assert_eq!(len, TYPE_VALUE.to_bytes().len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, TYPE_VALUE.to_str().unwrap());
		let len = unsafe { oakengine_node_get_name(orphan, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "Value".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Value");
		let len = unsafe { oakengine_node_get_short_name(orphan, buf.as_mut_ptr(), 512) };
		assert_eq!(
			len,
			"Value".len() as c_int,
			"short name falls back to the name"
		);
		// Label is empty until set.
		assert_eq!(
			unsafe { oakengine_node_get_label(orphan, buf.as_mut_ptr(), 512) },
			0
		);

		// ---- standalone copy (owned; free back to baseline) -------------
		let copy = unsafe { oakengine_node_create_copy(orphan) };
		assert!(!copy.is_null());
		assert_eq!(alive(), base + 3);
		let len = unsafe { oakengine_node_get_type_id(copy, buf.as_mut_ptr(), 512) };
		assert_eq!(len, TYPE_VALUE.to_bytes().len() as c_int);
		unsafe { oakengine_node_free(copy) };
		assert_eq!(
			alive(),
			base + 2,
			"freeing an owned copy must return the alive counter"
		);
		assert!(unsafe { oakengine_node_create_copy(std::ptr::null()) }.is_null());

		// ---- project add nodes ------------------------------------------
		let solid = unsafe { oakengine_project_add_node(project, TYPE_SOLID.as_ptr()) };
		assert!(!solid.is_null());
		let transform = unsafe { oakengine_project_add_node(project, TYPE_TRANSFORM.as_ptr()) };
		assert!(!transform.is_null());
		let value = unsafe { oakengine_project_add_node(project, TYPE_VALUE.as_ptr()) };
		assert!(!value.is_null());
		let value2 = unsafe { oakengine_project_add_node(project, TYPE_VALUE.as_ptr()) };
		assert!(!value2.is_null());
		let group = unsafe { oakengine_project_add_node(project, TYPE_GROUP.as_ptr()) };
		assert!(!group.is_null());
		let multicam = unsafe { oakengine_project_add_node(project, TYPE_MULTICAM.as_ptr()) };
		assert!(!multicam.is_null());
		// 6 added nodes + the root folder.
		assert_eq!(unsafe { oakengine_project_node_count(project) }, 7);
		// Unknown id → NULL + last error.
		assert!(unsafe { oakengine_project_add_node(project, c"org.oak.nope".as_ptr()) }.is_null());
		assert!(
			unsafe { oakengine_project_add_node(std::ptr::null_mut(), TYPE_VALUE.as_ptr()) }
				.is_null()
		);

		// The added nodes report their owning project.
		let owned_project = unsafe { oakengine_node_get_project(value) };
		assert!(!owned_project.is_null());
		unsafe { oakengine_project_free(owned_project) }; // borrowed project shell
		let owned_project2 = unsafe { oakengine_project_from_object(value) };
		assert!(!owned_project2.is_null());
		unsafe { oakengine_project_free(owned_project2) };

		// ---- node type queries ------------------------------------------
		assert_eq!(unsafe { oakengine_node_is_clip(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_track(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_viewer_output(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_footage(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_sequence(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_folder(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_group(group) }, 1);
		assert_eq!(unsafe { oakengine_node_is_group(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_multicam(multicam) }, 1);
		assert_eq!(unsafe { oakengine_node_is_multicam(solid) }, 0);
		assert_eq!(unsafe { oakengine_node_is_item(solid) }, 0);
		assert_eq!(
			unsafe { oakengine_node_is_item(group) },
			1,
			"group is a project-tree item"
		);

		// ---- label operations (undoable) --------------------------------
		assert_eq!(
			unsafe { oakengine_node_set_label(value, c"My Value".as_ptr()) },
			0
		);
		let len = unsafe { oakengine_node_get_label(value, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "My Value".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "My Value");
		// NULL label → empty label (documented).
		assert_eq!(
			unsafe { oakengine_node_set_label(value, std::ptr::null()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_get_label(value, buf.as_mut_ptr(), 512) },
			0
		);

		// set_label_ex matrix: undoable (1) and live (0).
		assert_eq!(
			unsafe { oakengine_node_set_label_ex(value, c"Ex".as_ptr(), 1) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_set_label_ex(value, c"Ex2".as_ptr(), 0) },
			0
		);
		let len = unsafe { oakengine_node_get_label(value, buf.as_mut_ptr(), 512) };
		assert_eq!(len, 3);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Ex2");

		// label_and_name: label wins over the name.
		let len = unsafe { oakengine_node_get_label_and_name(value, buf.as_mut_ptr(), 512) };
		assert_eq!(len, 3);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Ex2");
		// No label → the name.
		let len = unsafe { oakengine_node_get_label_and_name(solid, buf.as_mut_ptr(), 512) };
		assert!(len > 0);

		// rename_many: one multi command for several nodes.
		let mut nodes = [value, value2];
		assert_eq!(
			unsafe {
				oakengine_node_rename_many(
					nodes.as_mut_ptr(),
					2,
					c"Renamed".as_ptr(),
					std::ptr::null_mut(),
				)
			},
			0
		);
		let len = unsafe { oakengine_node_get_label(value, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "Renamed".len() as c_int);
		// count 0 is a no-op; count < 0 or a NULL entry is invalid.
		assert_eq!(
			unsafe {
				oakengine_node_rename_many(
					nodes.as_mut_ptr(),
					0,
					c"x".as_ptr(),
					std::ptr::null_mut(),
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_rename_many(
					nodes.as_mut_ptr(),
					-1,
					c"x".as_ptr(),
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_rename_many(
					std::ptr::null_mut(),
					2,
					c"x".as_ptr(),
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		nodes[1] = std::ptr::null_mut();
		assert_eq!(
			unsafe {
				oakengine_node_rename_many(
					nodes.as_mut_ptr(),
					2,
					c"x".as_ptr(),
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		// set_label_many delegates to rename_many.
		nodes = [value, value2];
		assert_eq!(
			unsafe { oakengine_node_set_label_many(nodes.as_mut_ptr(), 2, c"Many".as_ptr()) },
			0
		);

		// rename_command: opaque command pointer (caller owns → free).
		let cmd = unsafe { oakengine_node_rename_command(value, c"Cmd".as_ptr()) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert!(
			unsafe { oakengine_node_rename_command(std::ptr::null_mut(), c"x".as_ptr()) }.is_null()
		);
		// NULL label on the command is legal (empty label).
		let cmd = unsafe { oakengine_node_rename_command(value, std::ptr::null()) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };

		// ---- color labels -----------------------------------------------
		assert_eq!(unsafe { oakengine_node_get_color_label(value) }, -1);
		assert_eq!(
			unsafe { oakengine_node_get_effective_color_label(value) },
			-1
		);
		let cmd = unsafe { oakengine_node_set_color_label_command(value, 3) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		let mut cl_nodes = [value, value2];
		assert_eq!(
			unsafe { oakengine_node_set_color_label(cl_nodes.as_mut_ptr(), 2, 2) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_set_color_label(cl_nodes.as_mut_ptr(), 0, 2) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_set_color_label(cl_nodes.as_mut_ptr(), -1, 2) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_set_color_label(std::ptr::null_mut(), 1, 2) },
			E_INVALID
		);

		// ---- input introspection ----------------------------------------
		// Every node carries the standard enabled_in plus the value node's
		// type_in/value_in.
		assert_eq!(unsafe { oakengine_node_input_count(value) }, 3);
		let len = unsafe { oakengine_node_input_id(value, 0, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "enabled_in".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "enabled_in");
		let len = unsafe { oakengine_node_input_id(value, 1, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "type_in".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "type_in");
		let len = unsafe { oakengine_node_input_id(value, 2, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "value_in".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "value_in");
		assert_eq!(
			unsafe { oakengine_node_input_id(value, 999, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_input_id(value, -1, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_input_get_type(value, c"value_in".as_ptr()) },
			vt::FLOAT
		);
		// Texture inputs have no POD type code; the module reports NONE.
		assert_eq!(
			unsafe { oakengine_node_input_get_type(transform, c"tex_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connectable(transform, c"tex_in".as_ptr()) },
			1
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connectable(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_keyframable(value, c"value_in".as_ptr()) },
			1
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connected(transform, c"tex_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connected(value, c"tex_in".as_ptr()) },
			NODE_E_NOT_FOUND,
			"unknown input on a valid node"
		);
		// Input-name lookup (the value node's localized names).
		let len = unsafe {
			oakengine_node_get_input_name(value, c"value_in".as_ptr(), buf.as_mut_ptr(), 512)
		};
		assert_eq!(len, "Value".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Value");
		let len = unsafe {
			oakengine_node_get_input_name(value, c"type_in".as_ptr(), buf.as_mut_ptr(), 512)
		};
		assert_eq!(len, "Type".len() as c_int);
		assert_eq!(
			unsafe {
				oakengine_node_get_input_name(value, c"nope_in".as_ptr(), buf.as_mut_ptr(), 512)
			},
			NODE_E_NOT_FOUND
		);
		// Stub input flags are stable.
		assert_eq!(
			unsafe { oakengine_node_input_is_array(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_array_size(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_get_flags(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_get_data_type(value, c"value_in".as_ptr()) },
			-1
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_hidden(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_keyframed(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_keyframed_ex(value, c"value_in".as_ptr(), 0) },
			0
		);

		// ---- standard parameter access ----------------------------------
		assert_eq!(
			unsafe { oakengine_node_set_input(value, c"value_in".as_ptr(), &float_value(3.5)) },
			0
		);
		let mut out: OakNodeValue = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe { oakengine_node_get_input(value, c"value_in".as_ptr(), &mut out) },
			0
		);
		assert_eq!(out.kind, vt::FLOAT);
		assert!((out.f[0] - 3.5).abs() < 1e-6);
		// Type mismatch (INT kind into a float input) → module INVALID.
		assert_eq!(
			unsafe { oakengine_node_set_input(value, c"value_in".as_ptr(), &int_value(7)) },
			NODE_E_INVALID
		);
		// Unknown input → module NOT_FOUND.
		assert_eq!(
			unsafe { oakengine_node_set_input(value, c"nope_in".as_ptr(), &float_value(1.0)) },
			NODE_E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_get_input(value, c"nope_in".as_ptr(), &mut out) },
			NODE_E_NOT_FOUND
		);

		// set_standard_value_command → opaque command pointer (free).
		let cmd = unsafe {
			oakengine_node_set_standard_value_command(
				value,
				c"value_in".as_ptr(),
				-1,
				-1,
				&float_value(4.0),
			)
		};
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert!(unsafe {
			oakengine_node_set_standard_value_command(
				value,
				c"value_in".as_ptr(),
				-1,
				-1,
				std::ptr::null(),
			)
		}
		.is_null());

		// set_input_video_params_command is a documented stub → NULL.
		let params = unsafe { std::mem::zeroed::<OakVideoParamsPod>() };
		assert!(unsafe {
			oakengine_node_set_input_video_params_command(value, c"value_in".as_ptr(), &params)
		}
		.is_null());

		// ---- string parameter access (text generator) -------------------
		let textgen = unsafe { oakengine_node_factory_create_from_id(TYPE_TEXT.as_ptr()) };
		assert!(!textgen.is_null());
		// project + orphan + textgen owned (the added-node views are
		// borrowed; the facade releases the factory's owned handle).
		let alive_now = alive();
		assert_eq!(
			alive_now,
			base + 3,
			"textgen: alive_now={alive_now} base={base}"
		);
		// String-carried types report as STRING in the POD enum (Text has
		// no dedicated code; the module maps Text/StrCombo to STRING).
		assert_eq!(
			unsafe { oakengine_node_input_get_type(textgen, c"text_in".as_ptr()) },
			vt::STRING
		);
		// The generator's default text is "Sample Text" (11 chars).
		let len = unsafe {
			oakengine_node_get_input_string(textgen, c"text_in".as_ptr(), buf.as_mut_ptr(), 512)
		};
		assert_eq!(len, "Sample Text".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Sample Text");
		assert_eq!(
			unsafe {
				oakengine_node_set_input_string(
					textgen,
					c"text_in".as_ptr(),
					c"Hello Text".as_ptr(),
				)
			},
			0
		);
		let len2 = unsafe {
			oakengine_node_get_input_string(textgen, c"text_in".as_ptr(), buf.as_mut_ptr(), 512)
		};
		assert_eq!(len2, "Hello Text".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "Hello Text");
		// String write on a non-string input → module INVALID.
		assert_eq!(
			unsafe { oakengine_node_set_input_string(value, c"value_in".as_ptr(), c"x".as_ptr()) },
			NODE_E_INVALID
		);
		// get_input_string on a non-string input → module INVALID.
		assert_eq!(
			unsafe {
				oakengine_node_get_input_string(value, c"value_in".as_ptr(), buf.as_mut_ptr(), 512)
			},
			NODE_E_INVALID
		);
		// Unknown input → NOT_FOUND for the string getter.
		assert_eq!(
			unsafe {
				oakengine_node_get_input_string(value, c"nope_in".as_ptr(), buf.as_mut_ptr(), 512)
			},
			NODE_E_NOT_FOUND
		);
		unsafe { oakengine_node_free(textgen) };
		// project + orphan owned.
		assert_eq!(alive(), base + 2);

		// ---- at-time values ---------------------------------------------
		assert_eq!(
			unsafe {
				oakengine_node_frame_time_base(value, std::ptr::null_mut(), std::ptr::null_mut())
			},
			0
		);
		let mut tb_num: c_int = 0;
		let mut tb_den: c_int = 0;
		assert_eq!(
			unsafe { oakengine_node_frame_time_base(value, &mut tb_num, &mut tb_den) },
			0
		);
		assert_eq!(
			(tb_num, tb_den),
			(1001, 30000),
			"engine default time base without a sequence"
		);

		assert_eq!(
			unsafe {
				oakengine_node_set_input_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					-1,
					&float_value(0.5),
					0,
				)
			},
			0
		);
		let mut at: OakNodeValue = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe {
				oakengine_node_get_input_at_time(value, c"value_in".as_ptr(), -1, -1, 0, 0, &mut at)
			},
			0
		);
		assert_eq!(at.kind, vt::FLOAT);
		assert!((at.f[0] - 0.5).abs() < 1e-6);
		// At-time read on an unknown input → module NOT_FOUND.
		assert_eq!(
			unsafe {
				oakengine_node_get_input_at_time(value, c"nope_in".as_ptr(), -1, -1, 0, 0, &mut at)
			},
			NODE_E_NOT_FOUND
		);
		// At-time write on an unknown input → module NOT_FOUND.
		assert_eq!(
			unsafe {
				oakengine_node_set_input_at_time(
					value,
					c"nope_in".as_ptr(),
					-1,
					0,
					-1,
					&float_value(1.0),
					0,
				)
			},
			NODE_E_NOT_FOUND
		);

		// set_value_at_time_command → opaque command pointer (free).
		let cmd = unsafe {
			oakengine_node_set_value_at_time_command(
				value as *mut c_void,
				c"value_in".as_ptr(),
				-1,
				0,
				1,
				&float_value(0.75),
				-1,
				0,
			)
		};
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		// Zero denominator → NULL, never a crash.
		assert!(unsafe {
			oakengine_node_set_value_at_time_command(
				value as *mut c_void,
				c"value_in".as_ptr(),
				-1,
				0,
				0,
				&float_value(0.75),
				-1,
				0,
			)
		}
		.is_null());

		// String at-time path is a documented stub → Invalid.
		assert_eq!(
			unsafe {
				oakengine_node_set_input_string_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					c"x".as_ptr(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_input_string_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					-1,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_INVALID
		);
		// Bezier/binary at-time reads are documented stubs → Invalid.
		let mut six = [0.0f64; 6];
		assert_eq!(
			unsafe {
				oakengine_node_get_input_bezier_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					-1,
					six.as_mut_ptr(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_input_binary_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					-1,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_INVALID
		);

		// ---- input default value (stub) ---------------------------------
		assert_eq!(
			unsafe {
				oakengine_node_input_get_default_value(value, c"value_in".as_ptr(), 0, &mut out)
			},
			E_NOT_FOUND
		);

		// ---- input properties (stubs) -----------------------------------
		assert_eq!(
			unsafe {
				oakengine_node_input_has_property(value, c"value_in".as_ptr(), c"key".as_ptr())
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_set_input_property_string(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					c"v".as_ptr(),
					1,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_string(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					buf.as_mut_ptr(),
					512,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_number(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					0,
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		let mut dbl: f64 = 0.0;
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_number(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					0,
					&mut dbl,
				)
			},
			E_NOT_FOUND
		);
		let mut i64out: i64 = 0;
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_int(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					&mut i64out,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_rational(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
				)
			},
			E_NOT_FOUND,
			"stub NotFound with a valid node"
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_track_number(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					0,
					&mut dbl,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_input_get_property_count(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_key(
					value,
					c"value_in".as_ptr(),
					0,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_string_list_count(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_get_property_string_list(
					value,
					c"value_in".as_ptr(),
					c"key".as_ptr(),
					0,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_NOT_FOUND
		);

		// ---- copy inputs -------------------------------------------------
		assert_eq!(unsafe { oakengine_node_copy_inputs(value2, value) }, 0);
		assert_eq!(
			unsafe { oakengine_node_copy_inputs(std::ptr::null_mut(), value) },
			E_INVALID
		);

		// ---- value hint -------------------------------------------------
		assert_eq!(
			unsafe {
				oakengine_node_set_value_hint(value, c"value_in".as_ptr(), 0, 0, 0, c"".as_ptr())
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_set_value_hint(value, c"nope_in".as_ptr(), 0, 0, 0, c"".as_ptr())
			},
			NODE_E_NOT_FOUND
		);

		// ---- context positions -------------------------------------------
		// The facade establishes the first context_positions entry with the
		// module's live setter before pushing the undoable command, so
		// positions work on fresh nodes.
		let root = unsafe { oakengine_project_root(project) };
		let mut x: f64 = 0.0;
		let mut y: f64 = 0.0;
		let mut expanded: c_int = 0;
		assert_eq!(unsafe { oakengine_node_context_node_count(root) }, 0);
		assert_eq!(
			unsafe { oakengine_node_context_contains_node(root, value) },
			0
		);
		assert!(
			unsafe { oakengine_node_context_node_at(root, 0, &mut x, &mut y, &mut expanded) }
				.is_null()
		);
		// A fresh node gains its first context entry through the facade.
		assert_eq!(
			unsafe { oakengine_node_set_context_position(root, value, 10.0, 20.0) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_context_position(root, value, &mut x, &mut y, &mut expanded)
			},
			0
		);
		assert!((x - 10.0).abs() < 1e-9, "x={x}");
		assert!((y - 20.0).abs() < 1e-9, "y={y}");
		assert_eq!(expanded, 0);
		// Expanded flag flips through the same path.
		assert_eq!(
			unsafe { oakengine_node_set_context_expanded(root, value, 1) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_context_position(root, value, &mut x, &mut y, &mut expanded)
			},
			0
		);
		assert_eq!(expanded, 1);
		unsafe { oakengine_node_free(root) };

		// ---- array inputs (multicam sources_in is an array) --------------
		assert_eq!(
			unsafe { oakengine_node_array_insert_at(multicam, c"sources_in".as_ptr(), 0) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_array_insert_at(multicam, c"sources_in".as_ptr(), 1) },
			0
		);
		assert_eq!(unsafe { oakengine_multicam_get_source_count(multicam) }, 2);
		assert_eq!(
			unsafe { oakengine_node_array_remove_at(multicam, c"sources_in".as_ptr(), 1) },
			0
		);
		assert_eq!(unsafe { oakengine_multicam_get_source_count(multicam) }, 1);
		assert_eq!(
			unsafe { oakengine_node_array_remove_at(multicam, c"sources_in".as_ptr(), 0) },
			0
		);
		assert_eq!(unsafe { oakengine_multicam_get_source_count(multicam) }, 0);
		// Non-array input → module INVALID; negative index → facade INVALID.
		assert_eq!(
			unsafe { oakengine_node_array_insert_at(value, c"value_in".as_ptr(), 0) },
			NODE_E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_array_insert_at(value, c"value_in".as_ptr(), -1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_array_remove_at(value, c"value_in".as_ptr(), 0) },
			NODE_E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_multicam_get_source_count(value) },
			E_INVALID,
			"non-multicam node"
		);

		// ---- graph editing: connect / disconnect -------------------------
		assert_eq!(
			unsafe { oakengine_node_connect(solid, transform, c"tex_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connected(transform, c"tex_in".as_ptr()) },
			1
		);
		// A second connect on an already-connected input is rejected with the
		// module STATE error, mirroring the live `oaknode_node_connect`.
		assert_eq!(
			unsafe { oakengine_node_connect(solid, transform, c"tex_in".as_ptr()) },
			NODE_E_STATE
		);
		// Connecting to a non-connectable input → module INVALID.
		assert_eq!(
			unsafe { oakengine_node_connect(solid, value, c"value_in".as_ptr()) },
			NODE_E_INVALID
		);
		// Connecting to an unknown input → module NOT_FOUND.
		assert_eq!(
			unsafe { oakengine_node_connect(solid, value, c"nope_in".as_ptr()) },
			NODE_E_NOT_FOUND
		);

		// Connected-node + output-connection introspection.
		let conn =
			unsafe { oakengine_node_input_get_connected_node(transform, c"tex_in".as_ptr(), -1) };
		assert!(!conn.is_null());
		let len = unsafe { oakengine_node_get_type_id(conn, buf.as_mut_ptr(), 512) };
		assert_eq!(len, TYPE_SOLID.to_bytes().len() as c_int);
		unsafe { oakengine_node_free(conn) };
		assert!(unsafe {
			oakengine_node_input_get_connected_node(transform, c"nope_in".as_ptr(), -1)
		}
		.is_null());
		assert_eq!(unsafe { oakengine_node_output_connection_count(solid) }, 1);
		let mut conn_node: *mut OakEngineNode = std::ptr::null_mut();
		let mut elem: c_int = -1;
		assert_eq!(
			unsafe {
				oakengine_node_output_connection_at(
					solid,
					0,
					&mut conn_node,
					buf.as_mut_ptr(),
					512,
					&mut elem,
				)
			},
			0
		);
		assert!(!conn_node.is_null());
		assert_eq!(unsafe { read_buf(&mut buf) }, "tex_in");
		assert_eq!(elem, -1);
		unsafe { oakengine_node_free(conn_node) };
		// _ex variant reports the module's hidden flag (always 0).
		let mut hidden: c_int = 1;
		assert_eq!(
			unsafe {
				oakengine_node_output_connection_at_ex(
					solid,
					0,
					&mut conn_node,
					buf.as_mut_ptr(),
					512,
					&mut elem,
					&mut hidden,
				)
			},
			0
		);
		assert_eq!(hidden, 0);
		unsafe { oakengine_node_free(conn_node) };
		// Out-of-range output index.
		assert_eq!(
			unsafe {
				oakengine_node_output_connection_at(
					solid,
					1,
					&mut conn_node,
					buf.as_mut_ptr(),
					512,
					&mut elem,
				)
			},
			E_NOT_FOUND
		);

		// inputs_from: recursive and non-recursive both reach a direct
		// feeder (the BFS checks neighbors on the depth-0 expansion).
		assert_eq!(
			unsafe { oakengine_node_inputs_from(transform, solid, 1) },
			1
		);
		assert_eq!(
			unsafe { oakengine_node_inputs_from(transform, solid, 0) },
			1,
			"non-recursive still finds a direct feeder"
		);
		assert_eq!(unsafe { oakengine_node_inputs_from(value, solid, 1) }, 0);
		assert_eq!(
			unsafe { oakengine_node_inputs_from(std::ptr::null(), solid, 1) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_inputs_from(transform, std::ptr::null(), 1) },
			0
		);

		// Input-connection surfaces are stubs (outputs only).
		assert_eq!(
			unsafe { oakengine_node_input_connection_count_all(transform) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_connection_count(transform, c"tex_in".as_ptr(), -1) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_input_connection_at_all(
					transform,
					0,
					&mut conn_node,
					buf.as_mut_ptr(),
					512,
					&mut elem,
					&mut conn_node,
					&mut hidden,
				)
			},
			E_NOT_FOUND
		);
		assert!(unsafe {
			oakengine_node_input_connection_at(transform, c"tex_in".as_ptr(), -1, 0)
		}
		.is_null());

		// Disconnect + command variants.
		assert_eq!(
			unsafe { oakengine_node_disconnect(transform, c"tex_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_input_is_connected(transform, c"tex_in".as_ptr()) },
			0
		);
		// Disconnecting a disconnected input → module NOT_FOUND.
		assert_eq!(
			unsafe { oakengine_node_disconnect(transform, c"tex_in".as_ptr()) },
			NODE_E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_disconnect_ex(transform, c"tex_in".as_ptr(), -1) },
			NODE_E_NOT_FOUND
		);
		let cmd =
			unsafe { oakengine_node_connect_command(solid, transform, c"tex_in".as_ptr(), -1) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert_eq!(
			unsafe { oakengine_node_connect(solid, transform, c"tex_in".as_ptr()) },
			0
		);
		let cmd = unsafe { oakengine_node_disconnect_command(transform, c"tex_in".as_ptr(), -1) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };

		// block_link: link/unlink round trip (1 = changed, 0 = no-op).
		assert_eq!(
			unsafe { oakengine_block_link(solid as *mut c_void, value as *mut c_void, 1) },
			1
		);
		assert_eq!(
			unsafe { oakengine_block_link(solid as *mut c_void, value as *mut c_void, 1) },
			0,
			"already linked"
		);
		assert_eq!(
			unsafe { oakengine_block_link(solid as *mut c_void, value as *mut c_void, 0) },
			1
		);
		assert_eq!(
			unsafe { oakengine_block_link(solid as *mut c_void, value as *mut c_void, 0) },
			0,
			"already unlinked"
		);
		assert_eq!(
			unsafe { oakengine_block_link(std::ptr::null_mut(), value as *mut c_void, 1) },
			E_INVALID
		);
		// link_command → opaque command pointer (free).
		let cmd = unsafe { oakengine_node_link_command(solid, value, 1) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert!(unsafe { oakengine_node_link_command(std::ptr::null_mut(), value, 1) }.is_null());

		// ---- copy in graph ----------------------------------------------
		// copy_in_graph pushes a "Copy Node" command and returns an owned
		// copy in a scratch project (free to return the alive counter).
		let count_before = unsafe { oakengine_project_node_count(project) };
		let copied = unsafe { oakengine_node_copy_in_graph(value, std::ptr::null_mut()) };
		assert!(!copied.is_null());
		assert_eq!(
			alive(),
			base + 3,
			"copy-in-graph: owned copy + project + orphan"
		);
		assert_eq!(
			unsafe { oakengine_project_node_count(project) },
			count_before + 1,
			"the redo inserts a copy into the graph"
		);
		unsafe { oakengine_node_free(copied) };
		assert_eq!(alive(), base + 2);

		// add_to_project_command: opaque AddNode command for an orphan.
		let orphan2 = unsafe { oakengine_node_factory_create_from_id(TYPE_VALUE.as_ptr()) };
		assert!(!orphan2.is_null());
		let cmd = unsafe { oakengine_node_add_to_project_command(project, orphan2) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		unsafe { oakengine_node_free(orphan2) };
		// Adding a node already in the project → NULL command.
		assert!(unsafe { oakengine_node_add_to_project_command(project, value) }.is_null());

		// copy_dependency_graph is a documented stub → Invalid.
		let mut copies: *mut OakEngineNode = std::ptr::null_mut();
		let mut srcs = [value];
		assert_eq!(
			unsafe {
				oakengine_node_copy_dependency_graph(
					srcs.as_mut_ptr(),
					&mut copies,
					1,
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_copy_dependency_graph(
					std::ptr::null_mut(),
					&mut copies,
					1,
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);

		// connect_command_string is a documented stub → empty description.
		assert_eq!(
			unsafe {
				oakengine_node_connect_command_string(
					solid,
					value,
					c"value_in".as_ptr(),
					-1,
					buf.as_mut_ptr(),
					512,
				)
			},
			0
		);

		// transform_time_to is a documented identity stub.
		let mut rin: i64 = 0;
		let mut rind: i64 = 0;
		let mut rout: i64 = 0;
		let mut routd: i64 = 0;
		assert_eq!(
			unsafe {
				oakengine_node_transform_time_to(
					solid, value, 0, 0, 5, 1, 7, 2, &mut rin, &mut rind, &mut rout, &mut routd,
				)
			},
			0
		);
		assert_eq!((rin, rind, rout, routd), (5, 1, 7, 2));
		assert_eq!(
			unsafe {
				oakengine_node_transform_time_to(
					std::ptr::null_mut(),
					value,
					0,
					0,
					1,
					1,
					1,
					1,
					&mut rin,
					&mut rind,
					&mut rout,
					&mut routd,
				)
			},
			E_INVALID
		);

		// ---- keyframes (facade stubs + the real handle API) -------------
		assert_eq!(
			unsafe { oakengine_node_keyframe_count(value, c"value_in".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_node_keyframe_count_on_track(value, c"value_in".as_ptr(), 0, 0) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_at(
					value,
					c"value_in".as_ptr(),
					0,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
				)
			},
			E_NOT_FOUND,
			"stub NotFound with a valid node"
		);
		let mut kf_time: i64 = 0;
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_at(value, c"value_in".as_ptr(), 0, &mut kf_time, &mut out)
			},
			E_NOT_FOUND
		);
		let mut f1: f32 = 0.0;
		let mut f2: f32 = 0.0;
		let mut f3: f32 = 0.0;
		let mut f4: f32 = 0.0;
		let mut kty: c_int = 0;
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_get_easing(
					value,
					c"value_in".as_ptr(),
					0,
					&mut f1,
					&mut f2,
					&mut f3,
					&mut f4,
					&mut kty,
				)
			},
			E_NOT_FOUND
		);
		// keyframe_add pushes the value-at-time path (undoable).
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_add(
					value,
					c"value_in".as_ptr(),
					0,
					&float_value(1.5),
					0,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			},
			0
		);
		// Invalid easing type ordinal → Invalid.
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_add(
					value,
					c"value_in".as_ptr(),
					0,
					&float_value(1.5),
					3,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_add(
					value,
					c"value_in".as_ptr(),
					0,
					&float_value(1.5),
					-1,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			},
			E_INVALID
		);
		// keyframe_remove is a documented stub → NOT_FOUND.
		assert_eq!(
			unsafe { oakengine_node_keyframe_remove(value, c"value_in".as_ptr(), 0) },
			E_NOT_FOUND
		);
		// Keyframe stub enumerators.
		assert_eq!(
			unsafe { oakengine_node_has_keyframe_at_time(value, c"value_in".as_ptr(), -1, 0, 0) },
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_earliest_time(
					value,
					c"value_in".as_ptr(),
					-1,
					&mut i64out,
					std::ptr::null_mut(),
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_latest_time(
					value,
					c"value_in".as_ptr(),
					-1,
					std::ptr::null_mut(),
					&mut i64out,
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_closest_time_before(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					0,
					&mut i64out,
					&mut i64out,
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_closest_time_after(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					0,
					&mut i64out,
					&mut i64out,
				)
			},
			0
		);
		assert!(unsafe {
			oakengine_node_keyframe_handle_on_track(value, c"value_in".as_ptr(), -1, 0, 0)
		}
		.is_null());
		assert!(unsafe {
			oakengine_node_keyframe_handle_at_time(value, c"value_in".as_ptr(), -1, 0, 0, 1)
		}
		.is_null());
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					1,
					std::ptr::null_mut(),
					0,
				)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_toggle_at_time(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					0,
					1,
					c"t".as_ptr(),
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_set_input_keyframing(
					value,
					c"value_in".as_ptr(),
					-1,
					1,
					0,
					0,
					c"k".as_ptr(),
				)
			},
			E_INVALID
		);
		assert!(unsafe {
			oakengine_node_set_input_keyframing_command(value, c"value_in".as_ptr(), -1, 1)
		}
		.is_null());
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_paste(value, std::ptr::null_mut(), 1, c"p".as_ptr())
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_best_type_at_time(value, c"value_in".as_ptr(), -1, 0, 0, 2)
			},
			2,
			"caller default passes through"
		);
		assert_eq!(
			unsafe { oakengine_node_keyframe_track_count(value, c"value_in".as_ptr(), -1) },
			1
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_set_easing(
					value,
					c"value_in".as_ptr(),
					0,
					0,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			},
			E_NOT_FOUND
		);
		let ts: [i64; 1] = [0];
		let trk: [c_int; 1] = [0];
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_set_type_many(
					value,
					c"value_in".as_ptr(),
					-1,
					ts.as_ptr(),
					trk.as_ptr(),
					1,
					0,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_set_time_many(
					value,
					c"value_in".as_ptr(),
					-1,
					ts.as_ptr(),
					trk.as_ptr(),
					1,
					1,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_set_value_many(
					value,
					c"value_in".as_ptr(),
					-1,
					ts.as_ptr(),
					trk.as_ptr(),
					1,
					&float_value(1.0),
					&float_value(0.0),
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframes_set_bezier_many(
					value,
					c"value_in".as_ptr(),
					-1,
					ts.as_ptr(),
					trk.as_ptr(),
					1,
					0.0,
					0.0,
					1.0,
					1.0,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_node_keyframe_set_bezier_point(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					0,
					0,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_keyframes_clear(value, c"value_in".as_ptr()) },
			0,
			"documented no-op"
		);
		// insert_keyframe_command → opaque command pointer (free).
		let cmd = unsafe {
			oakengine_node_insert_keyframe_command(
				value,
				c"value_in".as_ptr(),
				-1,
				0,
				0,
				&float_value(2.0),
				0,
				0.0,
				0.0,
				0.0,
				0.0,
			)
		};
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert!(
			unsafe {
				oakengine_node_insert_keyframe_command(
					value,
					c"value_in".as_ptr(),
					-1,
					0,
					0,
					&float_value(2.0),
					3,
					0.0,
					0.0,
					0.0,
					0.0,
				)
			}
			.is_null(),
			"garbage easing type"
		);
		// remove_keyframe_command is a documented stub → NULL.
		let dummy_kf = Box::into_raw(Box::new(OakEngineKeyframe {
			handle: CHandle::null(),
		}));
		assert!(unsafe { oakengine_node_remove_keyframe_command(dummy_kf) }.is_null());
		unsafe { oakengine_keyframe_dispose(dummy_kf) };

		// ---- OakEngineKeyframe handle API --------------------------------
		let kf = unsafe {
			oakengine_keyframe_create(
				value,
				c"value_in".as_ptr(),
				-1,
				0,
				0,
				0,
				&float_value(1.0),
				0,
			)
		};
		assert!(!kf.is_null());
		let mut num: i64 = 0;
		let mut den: i64 = 0;
		assert_eq!(
			unsafe { oakengine_keyframe_get_time(kf, &mut num, &mut den) },
			0
		);
		assert_eq!(num, 0);
		assert_eq!(den, 1);
		let len = unsafe { oakengine_keyframe_get_input_id(kf, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "value_in".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "value_in");
		assert_eq!(unsafe { oakengine_keyframe_get_track(kf) }, 0);
		assert_eq!(unsafe { oakengine_keyframe_get_element(kf) }, -1);
		let parent = unsafe { oakengine_keyframe_get_node(kf) };
		assert!(!parent.is_null());
		let len = unsafe { oakengine_node_get_type_id(parent, buf.as_mut_ptr(), 512) };
		assert_eq!(len, TYPE_VALUE.to_bytes().len() as c_int);
		unsafe { oakengine_node_free(parent) };
		assert_eq!(unsafe { oakengine_keyframe_get_type(kf) }, 0);
		let mut kout: OakNodeValue = unsafe { std::mem::zeroed() };
		assert_eq!(unsafe { oakengine_keyframe_get_value(kf, &mut kout) }, 0);
		assert_eq!(kout.kind, vt::FLOAT);
		assert!((kout.f[0] - 1.0).abs() < 1e-9);

		// Live setters + readback.
		assert_eq!(
			unsafe { oakengine_keyframe_set_value_live(kf, &float_value(2.0)) },
			0
		);
		assert_eq!(unsafe { oakengine_keyframe_set_time_live(kf, 1, 1) }, 0);
		assert_eq!(
			unsafe { oakengine_keyframe_get_time(kf, &mut num, &mut den) },
			0
		);
		assert_eq!((num, den), (1, 1));
		assert_eq!(
			unsafe { oakengine_keyframe_set_bezier_point_live(kf, 0, 0.5, 0.25) },
			0
		);
		let mut bx: f64 = 0.0;
		let mut by: f64 = 0.0;
		assert_eq!(
			unsafe { oakengine_keyframe_get_bezier_point(kf, 0, &mut bx, &mut by) },
			0
		);
		assert!((bx - 0.5).abs() < 1e-9);
		assert!((by - 0.25).abs() < 1e-9);
		assert_eq!(
			unsafe { oakengine_keyframe_get_valid_bezier_point(kf, 1, &mut bx, &mut by) },
			0
		);
		// Bezier point index bounds.
		assert_eq!(
			unsafe { oakengine_keyframe_set_bezier_point_live(kf, 2, 0.0, 0.0) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_keyframe_get_bezier_point(kf, -1, &mut bx, &mut by) },
			E_INVALID
		);
		// compute_paste_value against the target node.
		let mut pv: OakNodeValue = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe { oakengine_keyframe_compute_paste_value(value, kf, &mut pv) },
			0
		);
		// Orphaned keyframe has no sibling.
		assert_eq!(
			unsafe { oakengine_keyframe_has_sibling_at_time(kf, 1, 1) },
			0
		);
		assert_eq!(
			unsafe { oakengine_keyframe_has_sibling_at_time(kf, 1, -1) },
			0,
			"negative track ignored"
		);
		// Undoable command creators over a keyframe handle.
		let cmd = unsafe { oakengine_keyframe_set_time_command(kf, 3) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		let cmd = unsafe { oakengine_keyframe_set_value_command(kf, &float_value(3.0)) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		assert!(unsafe { oakengine_keyframe_set_value_command(kf, std::ptr::null()) }.is_null());
		// keyframes_remove_many is a documented stub → Invalid.
		let mut kf_ptr = kf;
		assert_eq!(
			unsafe { oakengine_keyframes_remove_many(&mut kf_ptr, 1, c"r".as_ptr()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_keyframes_remove_many(std::ptr::null_mut(), 1, c"r".as_ptr()) },
			E_INVALID
		);
		// Dispose + NULL/empty dispose.
		unsafe { oakengine_keyframe_dispose(kf) };
		unsafe { oakengine_keyframe_dispose(std::ptr::null_mut()) };
		let empty_kf = Box::into_raw(Box::new(OakEngineKeyframe {
			handle: CHandle::null(),
		}));
		unsafe { oakengine_keyframe_dispose(empty_kf) };

		// ---- dragger -----------------------------------------------------
		let drag = unsafe { oakengine_dragger_create(value, c"value_in".as_ptr(), -1, 1) };
		assert!(!drag.is_null());
		assert_eq!(unsafe { oakengine_dragger_is_started(drag) }, 0);
		assert_eq!(unsafe { oakengine_dragger_start(drag, 0, 1, 0) }, 0);
		assert_eq!(unsafe { oakengine_dragger_is_started(drag) }, 1);
		assert_eq!(
			unsafe { oakengine_dragger_drag(drag, &float_value(2.5)) },
			0
		);
		assert_eq!(
			unsafe { oakengine_dragger_end(drag, c"Drag Value".as_ptr()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_dragger_is_started(drag) },
			0,
			"end resets the dragger"
		);
		// The dragged value landed in the standard value.
		let mut dv: OakNodeValue = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe { oakengine_node_get_input(value, c"value_in".as_ptr(), &mut dv) },
			0
		);
		assert!((dv.f[0] - 2.5).abs() < 1e-6);
		// drag before start → module STATE; start twice → module STATE.
		assert_eq!(
			unsafe { oakengine_dragger_drag(drag, &float_value(1.0)) },
			NODE_E_STATE,
			"drag without start"
		);
		assert_eq!(unsafe { oakengine_dragger_start(drag, 1, 1, 0) }, 0);
		assert_eq!(
			unsafe { oakengine_dragger_start(drag, 2, 1, 0) },
			NODE_E_STATE
		);
		assert_eq!(unsafe { oakengine_dragger_end(drag, c"x".as_ptr()) }, 0);
		assert_eq!(
			unsafe { oakengine_dragger_end(drag, c"x".as_ptr()) },
			NODE_E_STATE,
			"end without start"
		);
		unsafe { oakengine_dragger_free(drag) };
		unsafe { oakengine_dragger_free(std::ptr::null_mut()) };
		let empty_drag = Box::into_raw(Box::new(OakEngineNodeDragger {
			handle: CHandle::null(),
		}));
		unsafe { oakengine_dragger_free(empty_drag) };
		assert!(unsafe {
			oakengine_dragger_create(std::ptr::null_mut(), c"value_in".as_ptr(), -1, 1)
		}
		.is_null());

		// ---- group passthrough ------------------------------------------
		assert_eq!(unsafe { oakengine_group_input_passthrough_count(group) }, 0);
		let id_len = unsafe {
			oakengine_group_add_input_passthrough(
				group,
				value,
				c"value_in".as_ptr(),
				-1,
				c"".as_ptr(),
				buf.as_mut_ptr(),
				512,
			)
		};
		assert!(id_len > 0, "a passthrough id must be generated");
		let passthrough_id = unsafe { read_buf(&mut buf) };
		assert_eq!(unsafe { oakengine_group_input_passthrough_count(group) }, 1);
		// passthrough_at returns the id, the inner node, input and element.
		let mut pt_node: *mut OakEngineNode = std::ptr::null_mut();
		let mut pt_elem: c_int = 0;
		let len = unsafe {
			oakengine_group_input_passthrough_at(
				group,
				0,
				buf.as_mut_ptr(),
				512,
				&mut pt_node,
				buf.as_mut_ptr(),
				512,
				&mut pt_elem,
			)
		};
		assert!(len > 0);
		assert!(!pt_node.is_null());
		assert_eq!(unsafe { read_buf(&mut buf) }, "value_in");
		assert_eq!(pt_elem, -1);
		unsafe { oakengine_node_free(pt_node) };
		// Out-of-range passthrough index → module NOT_FOUND.
		assert_eq!(
			unsafe {
				oakengine_group_input_passthrough_at(
					group,
					5,
					buf.as_mut_ptr(),
					512,
					&mut pt_node,
					buf.as_mut_ptr(),
					512,
					&mut pt_elem,
				)
			},
			NODE_E_NOT_FOUND
		);
		// id_of_passthrough round trip: the module getters return the copied
		// string length (>= 0) on success, and the facade treats only
		// negative codes as failures.
		let len = unsafe {
			oakengine_group_get_id_of_passthrough(
				group,
				value,
				c"value_in".as_ptr(),
				-1,
				buf.as_mut_ptr(),
				512,
			)
		};
		assert!(len > 0, "the passthrough id must be returned");
		assert_eq!(
			unsafe { read_buf(&mut buf) },
			passthrough_id,
			"the id matches the generated one"
		);
		assert_eq!(
			unsafe {
				oakengine_group_get_id_of_passthrough(
					group,
					value,
					c"nope_in".as_ptr(),
					-1,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_NOT_FOUND
		);
		// get_passthrough_from_id writes the inner node, input and element.
		let passthrough_id_c = CString::new(passthrough_id.as_str()).unwrap();
		let mut back_node: *mut OakEngineNode = std::ptr::null_mut();
		let rc = unsafe {
			oakengine_group_get_passthrough_from_id(
				group,
				passthrough_id_c.as_ptr(),
				&mut back_node,
				buf.as_mut_ptr(),
				512,
				&mut pt_elem,
			)
		};
		assert_eq!(rc, 0);
		assert!(!back_node.is_null(), "out_node must be written");
		assert_eq!(unsafe { read_buf(&mut buf) }, "value_in");
		assert_eq!(pt_elem, -1);
		unsafe { oakengine_node_free(back_node) };
		assert_eq!(
			unsafe {
				oakengine_group_get_passthrough_from_id(
					group,
					c"no-such-id".as_ptr(),
					&mut back_node,
					buf.as_mut_ptr(),
					512,
					&mut pt_elem,
				)
			},
			E_NOT_FOUND
		);
		// Output passthrough set/get round trip.
		assert!(unsafe { oakengine_group_get_output_passthrough(group) }.is_null());
		assert_eq!(
			unsafe { oakengine_group_set_output_passthrough(group, value) },
			0
		);
		let op = unsafe { oakengine_group_get_output_passthrough(group) };
		assert!(!op.is_null());
		unsafe { oakengine_node_free(op) };
		// resolve_input resolves the passthrough to its inner node/input.
		let mut rn: *mut OakEngineNode = std::ptr::null_mut();
		let rc = unsafe {
			oakengine_group_resolve_input(
				group,
				c"value_in".as_ptr(),
				-1,
				&mut rn,
				buf.as_mut_ptr(),
				512,
				&mut pt_elem,
			)
		};
		assert_eq!(rc, 0);
		assert!(!rn.is_null(), "the resolved node must be written");
		assert_eq!(unsafe { read_buf(&mut buf) }, "value_in");
		assert_eq!(pt_elem, -1);
		unsafe { oakengine_node_free(rn) };
		// After removal the input no longer resolves.
		assert_eq!(
			unsafe {
				oakengine_group_remove_input_passthrough(group, value, c"value_in".as_ptr(), -1)
			},
			0
		);
		assert_eq!(unsafe { oakengine_group_input_passthrough_count(group) }, 0);
		assert_eq!(
			unsafe {
				oakengine_group_remove_input_passthrough(group, value, c"value_in".as_ptr(), -1)
			},
			NODE_E_NOT_FOUND,
			"already removed"
		);
		// Undoable add + set output.
		assert_eq!(
			unsafe {
				oakengine_group_add_input_passthrough_undoable(
					group,
					value,
					c"value_in".as_ptr(),
					-1,
					c"".as_ptr(),
				)
			},
			0
		);
		assert_eq!(unsafe { oakengine_group_input_passthrough_count(group) }, 1);
		assert_eq!(
			unsafe { oakengine_group_set_output_passthrough_undoable(group, value) },
			0
		);
		// Opaque group command creators (free).
		let cmd = unsafe {
			oakengine_group_add_input_passthrough_command(
				group,
				value,
				c"value_in".as_ptr(),
				-1,
				c"".as_ptr(),
			)
		};
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		let cmd = unsafe { oakengine_group_set_output_passthrough_command(group, value) };
		assert!(!cmd.is_null());
		unsafe { oakengine_undo_command_free(cmd) };
		// group_get_inner walks one passthrough level (the input id is
		// pre-filled in the inout buffer).
		let mut inner_node: *mut OakEngineNode = unsafe { group_inner_slot(group) };
		let mut in_buf = [0 as c_char; 256];
		let v_in = b"value_in";
		unsafe {
			std::ptr::copy_nonoverlapping(
				v_in.as_ptr() as *const c_char,
				in_buf.as_mut_ptr(),
				v_in.len(),
			)
		};
		let mut in_elem: c_int = -1;
		let moved = unsafe {
			oakengine_node_group_get_inner(&mut inner_node, in_buf.as_mut_ptr(), 256, &mut in_elem)
		};
		assert_eq!(moved, 1, "one passthrough level is walked");
		assert_eq!(unsafe { read_buf(&mut in_buf) }, "value_in");
		assert_eq!(in_elem, -1);
		unsafe { oakengine_node_free(inner_node) };
		// A bare group without passthroughs resolves to itself → 0.
		let bare = unsafe { oakengine_project_add_node(project, TYPE_GROUP.as_ptr()) };
		assert!(!bare.is_null());
		let mut bare_node: *mut OakEngineNode = unsafe { group_inner_slot(bare) };
		assert_eq!(
			unsafe {
				oakengine_node_group_get_inner(
					&mut bare_node,
					in_buf.as_mut_ptr(),
					256,
					&mut in_elem,
				)
			},
			0
		);
		unsafe { oakengine_node_free(bare_node) };

		// ---- multicam node surfaces -------------------------------------
		assert_eq!(unsafe { oakengine_multicam_get_source_count(multicam) }, 0);
		assert_eq!(
			unsafe { oakengine_multicam_get_current_source(multicam) },
			0
		);

		// ---- gizmo surfaces (stubs) -------------------------------------
		assert_eq!(unsafe { oakengine_node_has_gizmos(value) }, 0);
		assert_eq!(unsafe { oakengine_node_gizmo_count(value) }, 0);
		assert!(unsafe { oakengine_node_gizmo_at(value, 0) }.is_null());
		assert_eq!(
			unsafe {
				oakengine_node_update_gizmo_positions(value, std::ptr::null_mut(), 1920, 1080, 0, 1)
			},
			0
		);
		assert_eq!(
			unsafe {
				oakengine_node_update_gizmo_positions(
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					0,
					0,
					0,
					1,
				)
			},
			E_INVALID
		);

		// ---- node data (stub table) -------------------------------------
		let mut oty: c_int = 9;
		let mut oi: i64 = 9;
		for role in 0..=5 {
			assert_eq!(
				unsafe {
					oakengine_node_get_data(value, role, &mut oty, &mut oi, buf.as_mut_ptr(), 512)
				},
				0
			);
			assert_eq!(oty, 0, "stub reports no data");
		}
		assert_eq!(
			unsafe { oakengine_node_get_data(value, 6, &mut oty, &mut oi, buf.as_mut_ptr(), 512) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_get_data(value, -1, &mut oty, &mut oi, buf.as_mut_ptr(), 512) },
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_data(
					std::ptr::null(),
					0,
					&mut oty,
					&mut oi,
					buf.as_mut_ptr(),
					512,
				)
			},
			E_INVALID
		);

		// ---- exclusive dependencies / plugin messages / caches (stubs) --
		assert_eq!(
			unsafe { oakengine_node_get_exclusive_dependency_count(value) },
			0
		);
		assert!(unsafe { oakengine_node_get_exclusive_dependency_at(value, 0) }.is_null());
		assert_eq!(unsafe { oakengine_node_has_plugin(value) }, 0);
		assert_eq!(unsafe { oakengine_node_plugin_message_count(value) }, 0);
		assert_eq!(
			unsafe { oakengine_node_plugin_message_at(value, 0, &mut oty, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_plugin_clear_messages(value) },
			E_NOT_FOUND
		);
		assert!(unsafe { oakengine_node_get_thumbnail_cache(value) }.is_null());
		assert!(unsafe { oakengine_node_get_waveform_cache(value) }.is_null());
		assert!(
			unsafe { oakengine_node_get_video_frame_cache(value) }.is_null(),
			"no cache object on a plain node"
		);

		// ---- viewer / block / clip / track surfaces ---------------------
		assert!(unsafe { oakengine_viewer_output_get_connected_texture(value) }.is_null());
		assert!(
			unsafe { oakengine_clip_get_track(value) }.is_null(),
			"not a clip"
		);
		assert_eq!(
			unsafe { oakengine_track_get_type(value) },
			-1,
			"not a track"
		);
		assert_eq!(unsafe { oakengine_track_get_index(value) }, -1);
		assert!(unsafe { oakengine_track_get_sequence(value) }.is_null());
		assert_eq!(
			unsafe { oakengine_block_get_length_rational(value, &mut tb_num, &mut tb_den) },
			E_INVALID,
			"not a block"
		);
		assert_eq!(
			unsafe { oakengine_block_get_in_rational(value, &mut tb_num, &mut tb_den) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_block_get_out_rational(value, &mut tb_num, &mut tb_den) },
			E_INVALID
		);

		// ---- subtitle / shape (stubs) -----------------------------------
		assert_eq!(
			unsafe { oakengine_subtitle_get_text(value, buf.as_mut_ptr(), 512) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_subtitle_set_text(value, c"sub".as_ptr()) },
			E_INVALID
		);
		let params = unsafe { std::mem::zeroed::<OakVideoParamsPod>() };
		assert_eq!(
			unsafe {
				oakengine_shape_set_rect_undoable(
					value,
					0.0,
					0.0,
					10.0,
					10.0,
					&params,
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_shape_set_rect_undoable(
					std::ptr::null_mut(),
					0.0,
					0.0,
					10.0,
					10.0,
					&params,
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_shape_set_rect_undoable(
					value,
					0.0,
					0.0,
					10.0,
					10.0,
					std::ptr::null(),
					std::ptr::null_mut(),
				)
			},
			E_INVALID
		);
		// effect-input surface is a documented stub.
		assert_eq!(
			unsafe { oakengine_node_get_effect_input(value, buf.as_mut_ptr(), 512, &mut oty) },
			E_NOT_FOUND
		);

		// ---- bulk delete -------------------------------------------------
		// The solid → transform edge from the connect section is still live,
		// so a redundant reconnect is rejected with the module STATE error;
		// the edge is then deleted together with the node in one multi
		// command.
		assert_eq!(
			unsafe { oakengine_node_connect(solid, transform, c"tex_in".as_ptr()) },
			NODE_E_STATE,
			"the edge from the connect section is still live"
		);
		let del_nodes = [transform];
		let edge_outputs = [solid];
		let edge_inputs = [transform];
		let edge_ids = [c"tex_in".as_ptr() as *const c_char];
		let edge_elems: [c_int; 1] = [-1];
		let count_before = unsafe { oakengine_project_node_count(project) };
		assert_eq!(
			unsafe {
				oakengine_nodes_delete_many(
					del_nodes.as_ptr() as *mut *mut OakEngineNode,
					std::ptr::null_mut(),
					1,
					edge_outputs.as_ptr() as *mut *mut OakEngineNode,
					edge_inputs.as_ptr() as *mut *mut OakEngineNode,
					edge_ids.as_ptr() as *mut *const c_char,
					edge_elems.as_ptr(),
					1,
				)
			},
			0
		);
		assert_eq!(
			unsafe { oakengine_project_node_count(project) },
			count_before - 1,
			"delete must remove the node"
		);
		// Empty delete → Invalid ("nothing to delete").
		assert_eq!(
			unsafe {
				oakengine_nodes_delete_many(
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					0,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null(),
					0,
				)
			},
			E_INVALID
		);
		// _ex with a null node entry → Invalid.
		let mut null_nodes = [std::ptr::null_mut()];
		assert_eq!(
			unsafe {
				oakengine_nodes_delete_many_ex(
					null_nodes.as_mut_ptr(),
					std::ptr::null_mut(),
					1,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null(),
					0,
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null_mut(),
					std::ptr::null(),
					0,
				)
			},
			E_INVALID
		);

		// ---- folders -----------------------------------------------------
		let root = unsafe { oakengine_project_root(project) };
		let folder = unsafe { oakengine_folder_create(project, root, c"Bin".as_ptr()) };
		assert!(!folder.is_null());
		let len = unsafe { oakengine_node_get_label(folder, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "Bin".len() as c_int);
		assert_eq!(unsafe { oakengine_node_is_folder(folder) }, 1);
		// Root now has the folder as a child.
		let root2 = unsafe { oakengine_project_root(project) };
		assert_eq!(unsafe { oakengine_folder_item_child_count(root2) }, 1);
		assert_eq!(
			unsafe { oakengine_folder_has_child_recursive(root2, folder) },
			1
		);
		assert_eq!(unsafe { oakengine_folder_index_of_child(root2, folder) }, 0);
		let child = unsafe { oakengine_folder_item_child(root2, 0) };
		assert!(!child.is_null());
		let len = unsafe { oakengine_node_get_type_id(child, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "org.olivevideoeditor.Olive.folder".len() as c_int);
		unsafe { oakengine_node_free(child) };
		assert!(unsafe { oakengine_folder_item_child(root2, 5) }.is_null());
		assert_eq!(
			unsafe { oakengine_folder_item_child_count(std::ptr::null()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_folder_has_child_recursive(std::ptr::null(), folder) },
			0
		);
		assert_eq!(
			unsafe { oakengine_folder_has_child_recursive(root2, std::ptr::null()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_folder_index_of_child(std::ptr::null(), folder) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_folder_index_of_child(root2, std::ptr::null()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_folder_index_of_child(root2, value) },
			E_NOT_FOUND,
			"value is not in the root"
		);
		// folder_add_child is undoable; add the value node under the folder.
		assert_eq!(unsafe { oakengine_folder_add_child(folder, value) }, 0);
		assert_eq!(unsafe { oakengine_folder_item_child_count(folder) }, 1);
		assert_eq!(
			unsafe { oakengine_folder_item_child_count(root2) },
			1,
			"moved out of the root"
		);
		// A node already in one folder cannot be added to a second one: the
		// facade mirrors the module's live one-folder-per-node check (its
		// UNDOABLE command creator skips it) and rejects with STATE.
		assert_eq!(
			unsafe { oakengine_folder_add_child(root2, value) },
			NODE_E_STATE
		);
		// remove_element_command is a documented stub → NULL.
		assert!(unsafe { oakengine_folder_remove_element_command(root2, value) }.is_null());
		// move_children: move the value node back into the root.
		let mut mv = [value];
		assert_eq!(
			unsafe { oakengine_folder_move_children(mv.as_mut_ptr(), 1, root2, c"move".as_ptr()) },
			0
		);
		assert_eq!(unsafe { oakengine_folder_item_child_count(root2) }, 2);
		assert_eq!(unsafe { oakengine_folder_move_child(value, root2) }, 0);
		assert_eq!(
			unsafe {
				oakengine_folder_move_children(std::ptr::null_mut(), 1, root2, c"x".as_ptr())
			},
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_folder_move_children(mv.as_mut_ptr(), 0, root2, c"x".as_ptr()) },
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_folder_move_children(
					mv.as_mut_ptr(),
					1,
					std::ptr::null_mut(),
					c"x".as_ptr(),
				)
			},
			E_INVALID
		);
		// folder_create requires a folder parent.
		assert!(unsafe { oakengine_folder_create(project, value, c"x".as_ptr()) }.is_null());
		unsafe { oakengine_node_free(folder) };
		unsafe { oakengine_node_free(root2) };

		// ---- undo/redo over the global stack ----------------------------
		assert_eq!(
			unsafe { oakengine_project_can_undo(project) },
			1,
			"commands were pushed above"
		);
		assert_eq!(unsafe { oakengine_project_undo(project) }, 0);
		assert_eq!(unsafe { oakengine_project_can_redo(project) }, 1);
		assert_eq!(unsafe { oakengine_project_redo(project) }, 0);
		assert_eq!(
			unsafe { oakengine_project_can_undo(std::ptr::null_mut()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_can_redo(std::ptr::null_mut()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_undo(std::ptr::null_mut()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_project_redo(std::ptr::null_mut()) },
			E_INVALID
		);

		// ---- save → fresh load round trip --------------------------------
		let save_path =
			std::env::temp_dir().join(format!("oak_it_node_save-{}.ovexml", std::process::id()));
		let _ = std::fs::remove_file(&save_path);
		let sp = CString::new(save_path.to_string_lossy().into_owned()).unwrap();
		assert_eq!(unsafe { oakengine_project_save(project, sp.as_ptr()) }, 0);
		assert!(save_path.exists());
		// Save with NULL path uses the project filename.
		assert_eq!(
			unsafe { oakengine_project_save(project, std::ptr::null()) },
			0
		);
		assert_eq!(
			unsafe { oakengine_project_save(std::ptr::null_mut(), sp.as_ptr()) },
			E_INVALID
		);

		let project2 = oakengine_project_create();
		let mut err = [0 as c_char; 512];
		let rc = unsafe { oakengine_project_load(project2, sp.as_ptr(), err.as_mut_ptr(), 512) };
		if rc == 0 {
			assert!(unsafe { oakengine_project_node_count(project2) } >= 1);
		} else {
			let err_len = unsafe { CStr::from_ptr(err.as_ptr()) }.to_bytes().len();
			assert!(err_len > 0, "load failure must fill the error buffer");
		}
		unsafe { oakengine_project_free(project2) };
		// Load on an already-initialized project → E_STATE.
		assert_eq!(
			unsafe { oakengine_project_load(project, sp.as_ptr(), err.as_mut_ptr(), 512) },
			E_STATE
		);
		// Load with a NULL path → Invalid.
		let project3 = oakengine_project_create();
		assert_eq!(
			unsafe { oakengine_project_load(project3, std::ptr::null(), err.as_mut_ptr(), 512) },
			E_INVALID
		);
		// Load of a nonexistent file → failure + non-empty err buffer.
		let rc = unsafe {
			oakengine_project_load(
				project3,
				c"/no/such/project-file.ove".as_ptr(),
				err.as_mut_ptr(),
				512,
			)
		};
		assert!(rc < 0);
		assert!(unsafe { CStr::from_ptr(err.as_ptr()) }.to_bytes().len() > 0);
		unsafe { oakengine_project_free(project3) };
		let _ = std::fs::remove_file(&save_path);

		// ---- footage: probe / import / proxy / relink -------------------
		let media_a = fresh_temp_file("media-a.mp4", b"not-real-media");
		let media_a_c = CString::new(media_a.to_string_lossy().into_owned()).unwrap();

		// Probe a real file (module records the filename only; no decoder).
		let footage = unsafe { oakengine_footage_probe(media_a_c.as_ptr()) };
		assert!(!footage.is_null());
		let len = unsafe { oakengine_footage_get_filename(footage, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		assert_eq!(
			unsafe { read_buf(&mut buf) },
			media_a.to_string_lossy().into_owned()
		);
		assert_eq!(
			unsafe { oakengine_footage_get_decoder_name(footage, buf.as_mut_ptr(), 512) },
			0
		);
		assert_eq!(
			unsafe { oakengine_footage_get_video_stream_count(footage) },
			0
		);
		assert_eq!(
			unsafe { oakengine_footage_get_audio_stream_count(footage) },
			0
		);
		assert_eq!(
			unsafe { oakengine_footage_get_subtitle_stream_count(footage) },
			0
		);
		assert_eq!(unsafe { oakengine_footage_is_online(footage) }, 1);
		let mut secs: f64 = -1.0;
		assert_eq!(
			unsafe { oakengine_footage_get_duration(footage, &mut secs) },
			0
		);
		assert_eq!(secs, 0.0, "module footage has no media duration");
		// No streams → stream accessors report NOT_FOUND.
		let mut vinfo: OakFootageVideoInfo = unsafe { std::mem::zeroed() };
		let mut ainfo: OakFootageAudioInfo = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe { oakengine_footage_get_video_stream_info(footage, 0, &mut vinfo) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_audio_stream_info(footage, 0, &mut ainfo) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_video_stream_info(footage, -1, &mut vinfo) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_video_stream_info(std::ptr::null_mut(), 0, &mut vinfo) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_get_video_stream_info(footage, 0, std::ptr::null_mut()) },
			E_INVALID
		);
		let mut cr: c_int = 0;
		let mut il: c_int = 0;
		let mut pm: c_int = 0;
		assert_eq!(
			unsafe {
				oakengine_footage_get_video_stream_overrides(
					footage,
					0,
					buf.as_mut_ptr(),
					512,
					&mut cr,
					&mut il,
					&mut pm,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe {
				oakengine_footage_set_video_stream_overrides(footage, 0, c"".as_ptr(), 0, 0, 0)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_pixel_aspect(footage, 0, &mut tb_num, &mut tb_den) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_set_pixel_aspect(footage, 0, 1, 1) },
			E_NOT_FOUND
		);
		// Bad pixel-aspect ratio is rejected before the stream lookup.
		assert_eq!(
			unsafe { oakengine_footage_set_pixel_aspect(footage, 0, 0, 1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_set_pixel_aspect(footage, 0, 1, 0) },
			E_INVALID
		);
		let mut si: i64 = 0;
		let mut dur: i64 = 0;
		assert_eq!(
			unsafe {
				oakengine_footage_get_image_sequence_params(
					footage,
					0,
					&mut si,
					&mut dur,
					&mut tb_num,
					&mut tb_den,
				)
			},
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_set_image_sequence_params(footage, 0, 0, 1, 25, 1) },
			E_NOT_FOUND
		);
		// Bad image-sequence params are rejected first.
		assert_eq!(
			unsafe { oakengine_footage_set_image_sequence_params(footage, 0, -1, 1, 25, 1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_set_image_sequence_params(footage, 0, 0, 0, 25, 1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_set_image_sequence_params(footage, 0, 0, 1, 0, 1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_set_image_sequence_params(footage, 0, 0, 1, 25, 0) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_get_stream_enabled(footage, 0, 0) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_stream_enabled(footage, 3, 0) },
			E_NOT_FOUND,
			"garbage track type"
		);
		assert_eq!(
			unsafe { oakengine_footage_set_stream_enabled(footage, 0, 0, 1) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_stream_reference(footage, 0, &mut oty, &mut tb_num) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_get_stream_reference(footage, -1, &mut oty, &mut tb_num) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_describe_video_stream(footage, 0, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_footage_describe_audio_stream(footage, 0, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		// Source start time is a documented stub (0/1).
		assert_eq!(
			unsafe { oakengine_footage_get_source_start_time(footage, &mut tb_num, &mut tb_den) },
			0
		);
		assert_eq!((tb_num, tb_den), (0, 1));
		assert_eq!(
			unsafe { oakengine_footage_set_source_start_time(footage, 1, 0, 1) },
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_footage_get_source_start_time_source(footage, buf.as_mut_ptr(), 512)
			},
			0
		);
		// Colorspace candidates are stubs.
		assert_eq!(unsafe { oakengine_footage_colorspace_count(footage) }, 0);
		assert_eq!(
			unsafe { oakengine_footage_colorspace_at(footage, 0, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		// Proxy state: defaults, set round trip, delete/clear.
		assert_eq!(unsafe { oakengine_footage_proxy_get_state(footage) }, 0);
		assert_eq!(unsafe { oakengine_footage_proxy_is_enabled(footage) }, 0);
		assert_eq!(
			unsafe { oakengine_footage_proxy_get_path(footage, buf.as_mut_ptr(), 512) },
			0
		);
		assert_eq!(
			unsafe { oakengine_footage_proxy_generate(footage) },
			E_STATE,
			"documented stub"
		);
		assert_eq!(
			unsafe { oakengine_footage_set_proxy(footage, c"/tmp/proxy.mp4".as_ptr(), 1, 0, 1, 1) },
			0
		);
		assert_eq!(unsafe { oakengine_footage_proxy_get_state(footage) }, 1);
		assert_eq!(unsafe { oakengine_footage_proxy_is_enabled(footage) }, 1);
		let len = unsafe { oakengine_footage_proxy_get_path(footage, buf.as_mut_ptr(), 512) };
		assert_eq!(len, "/tmp/proxy.mp4".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "/tmp/proxy.mp4");
		assert_eq!(unsafe { oakengine_footage_proxy_delete(footage) }, 0);
		assert_eq!(unsafe { oakengine_footage_proxy_get_state(footage) }, 0);
		assert_eq!(
			unsafe { oakengine_footage_proxy_set_enabled(footage, 1) },
			0
		);
		assert_eq!(unsafe { oakengine_footage_proxy_is_enabled(footage) }, 1);
		assert_eq!(unsafe { oakengine_footage_clear_proxy(footage) }, 0);
		assert_eq!(unsafe { oakengine_footage_proxy_is_enabled(footage) }, 0);
		// Custom proxy params stubs.
		assert_eq!(
			unsafe { oakengine_footage_has_custom_proxy_params(footage) },
			0
		);
		let mut pp: OakProxyParams = unsafe { std::mem::zeroed() };
		assert_eq!(
			unsafe { oakengine_footage_get_effective_proxy_params(footage, &mut pp) },
			0
		);
		assert_eq!(pp.width, 0);
		assert_eq!(
			unsafe { oakengine_footage_set_custom_proxy_params(footage, &pp) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_clear_custom_proxy_params(footage) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_footage_invalidate(footage) },
			0,
			"documented no-op"
		);
		// Relink requires an existing file.
		let media_b = fresh_temp_file("media-b.mp4", b"other");
		let media_b_c = CString::new(media_b.to_string_lossy().into_owned()).unwrap();
		assert_eq!(
			unsafe { oakengine_footage_relink(footage, media_b_c.as_ptr()) },
			0
		);
		let len = unsafe { oakengine_footage_get_filename(footage, buf.as_mut_ptr(), 512) };
		assert_eq!(
			unsafe { read_buf(&mut buf) },
			media_b.to_string_lossy().into_owned()
		);
		let _ = len;
		// Relink to a nonexistent file → NOT_FOUND + footage error text.
		assert_eq!(
			unsafe { oakengine_footage_relink(footage, c"/no/such/file.mp4".as_ptr()) },
			E_NOT_FOUND
		);
		let err_len = unsafe { oakengine_footage_last_error(buf.as_mut_ptr(), 512) };
		assert!(
			err_len > 0,
			"footage_last_error must be non-empty after a failed relink"
		);
		// NULL path → Invalid.
		assert_eq!(
			unsafe { oakengine_footage_relink(footage, std::ptr::null()) },
			E_INVALID
		);
		unsafe { oakengine_footage_free(footage) };
		unsafe { oakengine_footage_free(std::ptr::null_mut()) };
		let empty_ftg = Box::into_raw(Box::new(OakEngineFootage {
			handle: CHandle::null(),
		}));
		unsafe { oakengine_footage_free(empty_ftg) };

		// Probe failure paths.
		let probe_null = unsafe { oakengine_footage_probe(std::ptr::null()) };
		assert!(probe_null.is_null());
		let probe_missing = unsafe { oakengine_footage_probe(c"/no/such/media.mp4".as_ptr()) };
		assert!(probe_missing.is_null());
		let err_len = unsafe { oakengine_footage_last_error(buf.as_mut_ptr(), 512) };
		assert!(err_len > 0);

		// Import into the project (real file).
		let imported = unsafe { oakengine_project_import_footage(project, media_b_c.as_ptr()) };
		assert!(!imported.is_null());
		assert_eq!(unsafe { oakengine_project_footage_count(project) }, 1);
		let len = unsafe { oakengine_project_footage_filename(project, 0, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		assert_eq!(
			unsafe { oakengine_project_footage_is_online(project, 0) },
			1
		);
		assert_eq!(
			unsafe { oakengine_project_footage_filename(project, 5, buf.as_mut_ptr(), 512) },
			E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_project_footage_is_online(project, 5) },
			E_NOT_FOUND
		);
		// The footage node is in the graph: borrow + validity.
		let footage_idx = unsafe { find_node(project, TYPE_FOOTAGE.to_str().unwrap()) };
		assert!(footage_idx >= 0);
		let footage_node = unsafe { oakengine_project_node_at(project, footage_idx) };
		assert_eq!(unsafe { oakengine_node_is_footage(footage_node) }, 1);
		assert_eq!(
			unsafe { oakengine_footage_is_valid(footage_node) },
			0,
			"module footage is never probed"
		);
		// `oakengine_footage_borrow` takes its OWN addref'd reference, so the
		// borrow and the source node shell can BOTH be freed (no double-free).
		let borrowed = unsafe { oakengine_footage_borrow(footage_node) };
		assert!(!borrowed.is_null());
		let len = unsafe { oakengine_footage_get_filename(borrowed, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		unsafe { oakengine_footage_free(borrowed) };
		unsafe { oakengine_node_free(footage_node) };
		// Borrow of a non-footage node → NULL.
		assert!(unsafe { oakengine_footage_borrow(value) }.is_null());
		assert_eq!(unsafe { oakengine_footage_is_valid(value) }, 0);
		// Import failure paths.
		assert!(unsafe {
			oakengine_project_import_footage(project, c"/no/such/media.mp4".as_ptr())
		}
		.is_null());
		assert!(unsafe {
			oakengine_project_import_footage(std::ptr::null_mut(), media_b_c.as_ptr())
		}
		.is_null());
		assert!(unsafe { oakengine_project_import_footage(project, std::ptr::null()) }.is_null());

		// find_offline_footage: make the imported footage offline and
		// relink it from a search directory.
		let media_b_basename = media_b.file_name().unwrap().to_string_lossy().into_owned();
		let _ = std::fs::remove_file(&media_b); // now offline
		assert_eq!(
			unsafe { oakengine_project_footage_is_online(project, 0) },
			0
		);
		let search_dir =
			std::env::temp_dir().join(format!("oak-it-node-search-{}", std::process::id()));
		let _ = std::fs::remove_dir_all(&search_dir);
		std::fs::create_dir_all(&search_dir).unwrap();
		std::fs::write(search_dir.join(&media_b_basename), b"found").unwrap();
		let search_c = CString::new(search_dir.to_string_lossy().into_owned()).unwrap();
		assert_eq!(
			unsafe { oakengine_project_find_offline_footage(project, search_c.as_ptr()) },
			1
		);
		assert_eq!(
			unsafe { oakengine_project_footage_is_online(project, 0) },
			1
		);
		assert_eq!(
			unsafe { oakengine_project_find_offline_footage(project, std::ptr::null()) },
			E_INVALID
		);
		assert_eq!(
			unsafe {
				oakengine_project_find_offline_footage(std::ptr::null_mut(), search_c.as_ptr())
			},
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_project_find_offline_footage(project, c"/no/such/dir".as_ptr()) },
			E_INVALID
		);

		// ---- remove a node + free the project ---------------------------
		assert_eq!(unsafe { oakengine_project_remove_node(project, value2) }, 0);
		assert_eq!(
			unsafe { oakengine_project_remove_node(project, value2) },
			E_INVALID,
			"already removed"
		);
		assert_eq!(
			unsafe { oakengine_project_remove_node(std::ptr::null_mut(), value) },
			E_INVALID
		);

		// Free borrowed shells captured above.
		unsafe { oakengine_node_free(value) };
		unsafe { oakengine_node_free(value2) };
		unsafe { oakengine_node_free(solid) };
		unsafe { oakengine_node_free(group) };
		unsafe { oakengine_node_free(bare) };
		unsafe { oakengine_node_free(multicam) };
		unsafe { oakengine_node_free(orphan) };
		unsafe { oakengine_footage_free(imported) };
		unsafe { oakengine_project_free(project) };
		// One intentional process-lifetime leak remains: the hidden probe
		// project created by the first `oakengine_footage_probe` (leaked
		// like the C++ EngineCore shell). The add_node factory handles are
		// released by the facade, so they no longer leak.
		assert_eq!(alive(), base + 1, "only the probe project leak remains");
	});
}

// ---------------------------------------------------------------------------
// Effect chain surface (node.h effect-input family)
// ---------------------------------------------------------------------------

/// Effect chain enumeration and edits over the facade: insert at index,
/// remove, reorder, enable toggle — each a single undoable row — plus the
/// NULL and illegal-input matrix of the new exports. The chain semantics
/// mirror the C++ original (`Node::GetEffectInputID` / `GetConnectedOutput`
/// walk): effects attach to the host's effect input, ordered closest-to-
/// source first.
#[test]
fn node_effect_chain_edits() {
	with_owned(|| {
		common::force_link();
		let _ = force_oakundo_command_link();
		let base = alive();
		let mut buf = [0 as c_char; 512];
		let mut element: c_int = 0;

		// ---- fixtures: a transform host + a plain value node ---------------
		let project = oakengine_project_create();
		assert!(!project.is_null());
		assert_eq!(unsafe { oakengine_project_new(project) }, 0);
		let host = unsafe { oakengine_project_add_node(project, TYPE_TRANSFORM.as_ptr()) };
		assert!(!host.is_null());
		let value = unsafe { oakengine_project_add_node(project, TYPE_VALUE.as_ptr()) };
		assert!(!value.is_null());

		// The transform's effect input is "tex_in".
		let len =
			unsafe { oakengine_node_get_effect_input(host, buf.as_mut_ptr(), 512, &mut element) };
		assert_eq!(len, "tex_in".len() as c_int);
		assert_eq!(unsafe { read_buf(&mut buf) }, "tex_in");
		assert_eq!(element, -1, "non-array input element");
		// A node without an effect input cannot host effects.
		assert_eq!(
			unsafe { oakengine_node_get_effect_input(value, buf.as_mut_ptr(), 512, &mut element) },
			E_NOT_FOUND
		);

		// ---- enumeration on an empty chain ---------------------------------
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 0);
		assert!(unsafe { oakengine_node_effect_at(host, 0) }.is_null());

		// ---- insert three effects: opacity, blur, transform -----------------
		// Inserting at 0 twice stacks each new effect closest to the source;
		// inserting at len appends next to the host.
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 0, TYPE_BLUR.as_ptr()) },
			0
		);
		eprintln!("[dbg] count after blur insert: {}", unsafe {
			oakengine_node_effect_count(host)
		});
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 0, TYPE_OPACITY.as_ptr()) },
			0
		);
		eprintln!("[dbg] count after opacity insert: {}", unsafe {
			oakengine_node_effect_count(host)
		});
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 2, TYPE_TRANSFORM.as_ptr()) },
			0
		);
		eprintln!("[dbg] count after transform insert: {}", unsafe {
			oakengine_node_effect_count(host)
		});
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 3);

		let eff0 = unsafe { oakengine_node_effect_at(host, 0) };
		let eff1 = unsafe { oakengine_node_effect_at(host, 1) };
		let eff2 = unsafe { oakengine_node_effect_at(host, 2) };
		assert!(!eff0.is_null() && !eff1.is_null() && !eff2.is_null());
		assert!(unsafe { oakengine_node_effect_at(host, -1) }.is_null());
		assert!(unsafe { oakengine_node_effect_at(host, 99) }.is_null());
		// Signal order: opacity (source side) → blur → transform (host side).
		assert_eq!(
			unsafe { oakengine_node_get_type_id(eff0, buf.as_mut_ptr(), 512) },
			TYPE_OPACITY.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe { read_buf(&mut buf) },
			TYPE_OPACITY.to_str().unwrap()
		);
		assert_eq!(
			unsafe { oakengine_node_get_type_id(eff1, buf.as_mut_ptr(), 512) },
			TYPE_BLUR.to_bytes().len() as c_int
		);
		assert_eq!(unsafe { read_buf(&mut buf) }, TYPE_BLUR.to_str().unwrap());
		assert_eq!(
			unsafe { oakengine_node_get_type_id(eff2, buf.as_mut_ptr(), 512) },
			TYPE_TRANSFORM.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe { read_buf(&mut buf) },
			TYPE_TRANSFORM.to_str().unwrap()
		);

		// Effect nodes carry the video-effect flag; plain nodes do not.
		assert_ne!(
			unsafe { oakengine_node_get_flags(eff0) } & oakengine_node_flag_video_effect(),
			0
		);
		assert_ne!(
			unsafe { oakengine_node_get_flags(eff1) } & oakengine_node_flag_video_effect(),
			0
		);
		assert_eq!(
			unsafe { oakengine_node_get_flags(value) } & oakengine_node_flag_video_effect(),
			0
		);

		// Stable identities (the stack's card ids) are non-zero.
		let eff1_identity = unsafe { oakengine_node_identity(eff1) };
		assert!(eff1_identity > 0);

		// ---- enable toggle --------------------------------------------------
		assert_eq!(unsafe { oakengine_node_is_enabled(eff1) }, 1);
		assert_eq!(unsafe { oakengine_node_effect_set_enabled(eff1, 0) }, 0);
		assert_eq!(unsafe { oakengine_node_is_enabled(eff1) }, 0);
		assert_eq!(unsafe { oakengine_node_effect_set_enabled(eff1, 1) }, 0);
		assert_eq!(unsafe { oakengine_node_is_enabled(eff1) }, 1);

		// ---- reorder: move blur (index 1) to the end -----------------------
		assert_eq!(unsafe { oakengine_node_effect_move(host, eff1, 2) }, 0);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 0) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_OPACITY.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 1) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_TRANSFORM.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 2) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_BLUR.to_bytes().len() as c_int
		);

		// ---- remove transform (now at index 1) ------------------------------
		let t_at_1 = unsafe { oakengine_node_effect_at(host, 1) };
		assert!(!t_at_1.is_null());
		assert_eq!(unsafe { oakengine_node_effect_remove(host, t_at_1) }, 0);
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 2);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 0) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_OPACITY.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 1) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_BLUR.to_bytes().len() as c_int
		);

		// ---- the edit is one undo row: undo/redo restores the chain --------
		assert_eq!(unsafe { oakengine_project_undo(project) }, 0);
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 3);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 0) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_OPACITY.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 1) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_TRANSFORM.to_bytes().len() as c_int
		);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 2) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_BLUR.to_bytes().len() as c_int
		);
		assert_eq!(unsafe { oakengine_project_redo(project) }, 0);
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 2);

		// ---- out-of-range insert clamps to the host side -------------------
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 99, TYPE_BLUR.as_ptr()) },
			0
		);
		assert_eq!(unsafe { oakengine_node_effect_count(host) }, 3);
		assert_eq!(
			unsafe {
				oakengine_node_get_type_id(
					unsafe { oakengine_node_effect_at(host, 2) },
					buf.as_mut_ptr(),
					512,
				)
			},
			TYPE_BLUR.to_bytes().len() as c_int
		);

		// ---- illegal inputs -------------------------------------------------
		assert_eq!(
			unsafe { oakengine_node_effect_insert(std::ptr::null_mut(), 0, TYPE_BLUR.as_ptr()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 0, std::ptr::null()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 0, c"org.oak.no.such.node".as_ptr()) },
			E_FAILED,
			"unknown factory id"
		);
		assert_eq!(
			unsafe { oakengine_node_effect_insert(host, 0, TYPE_VALUE.as_ptr()) },
			E_INVALID,
			"a node without an effect input cannot be chained"
		);
		assert_eq!(
			unsafe { oakengine_node_effect_insert(value, 0, TYPE_BLUR.as_ptr()) },
			E_NOT_FOUND,
			"a host without an effect input hosts no chain"
		);
		assert_eq!(
			unsafe { oakengine_node_effect_remove(std::ptr::null_mut(), eff1) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_remove(host, std::ptr::null_mut()) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_remove(host, value) },
			E_NOT_FOUND,
			"not a member of the chain"
		);
		assert_eq!(
			unsafe { oakengine_node_effect_move(std::ptr::null_mut(), eff1, 0) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_move(host, std::ptr::null_mut(), 0) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_effect_move(host, value, 0) },
			E_NOT_FOUND,
			"not a member of the chain"
		);
		assert_eq!(
			unsafe { oakengine_node_effect_set_enabled(std::ptr::null_mut(), 0) },
			E_INVALID
		);
		assert_eq!(
			unsafe { oakengine_node_is_enabled(std::ptr::null_mut()) },
			0
		);
		assert_eq!(unsafe { oakengine_node_identity(std::ptr::null_mut()) }, 0);
		assert_eq!(
			unsafe { oakengine_node_effect_count(std::ptr::null_mut()) },
			0
		);
		assert!(unsafe { oakengine_node_effect_at(std::ptr::null_mut(), 0) }.is_null());
		assert_eq!(
			unsafe {
				oakengine_node_get_effect_input(
					std::ptr::null_mut(),
					buf.as_mut_ptr(),
					512,
					&mut element,
				)
			},
			E_INVALID
		);
		assert_eq!(unsafe { oakengine_node_get_flags(std::ptr::null_mut()) }, 0);

		// ---- factory id enumeration + clip → node conversion ---------------
		let factory_count = oakengine_node_factory_id_count();
		assert!(factory_count > 0);
		let len = unsafe { oakengine_node_factory_id_at(0, buf.as_mut_ptr(), 512) };
		assert!(len > 0);
		let first_id = unsafe { read_buf(&mut buf) };
		let name_len = unsafe {
			oakengine_node_factory_name_from_id(
				first_id.as_ptr() as *const c_char,
				buf.as_mut_ptr(),
				512,
			)
		};
		assert!(name_len > 0, "factory name resolves for an enumerated id");
		assert_eq!(
			unsafe { oakengine_node_factory_id_at(-1, buf.as_mut_ptr(), 512) },
			NODE_E_NOT_FOUND
		);
		assert_eq!(
			unsafe { oakengine_node_factory_id_at(factory_count, buf.as_mut_ptr(), 512) },
			NODE_E_NOT_FOUND
		);
		// `oakengine_clip_as_node` converts a clip box to its node view (the
		// engine opaque types share one CHandle layout; a plain node box
		// exercises the same conversion path).
		let clip_view = value as *mut oakengine::handle::OakEngineClip;
		let as_node = unsafe { oakengine_clip_as_node(clip_view) };
		assert!(!as_node.is_null());
		assert_eq!(
			unsafe { oakengine_node_get_type_id(as_node, buf.as_mut_ptr(), 512) },
			TYPE_VALUE.to_bytes().len() as c_int
		);
		assert!(unsafe { oakengine_clip_as_node(std::ptr::null_mut()) }.is_null());

		// ---- cleanup --------------------------------------------------------
		unsafe { oakengine_node_free(eff0) };
		unsafe { oakengine_node_free(eff1) };
		unsafe { oakengine_node_free(eff2) };
		unsafe { oakengine_node_free(t_at_1) };
		unsafe { oakengine_node_free(as_node) };
		unsafe { oakengine_node_free(host) };
		unsafe { oakengine_node_free(value) };
		unsafe { oakengine_project_free(project) };
		// No probe project is involved in this test (unlike the footage
		// family above): the effect edits keep every node inside the project
		// graph, so freeing the project returns the alive counter to base.
		assert_eq!(alive(), base, "effect-chain edits must not leak boxes");
	});
}

// ---------------------------------------------------------------------------
// Illegal inputs: NULL / empty handles / bad sizes / garbage (parallel-safe)
// ---------------------------------------------------------------------------

/// NULL and empty-`CHandle` boxes for the handle-taking exports: every
/// call must return a clean negative code or the documented no-op, never a
/// crash. Runs in parallel (no undo-stack or alive-counter access).
#[test]
fn null_and_empty_handle_failure_paths() {
	common::force_link();
	let _ = force_oakundo_command_link();
	let mut buf = [0 as c_char; 512];
	let mut out: OakNodeValue = unsafe { std::mem::zeroed() };
	let mut num: i64 = 0;
	let mut den: i64 = 0;
	// Scratch out-params reused across the failure calls below.
	let mut f64a: f64 = 0.0;
	let mut f64b: f64 = 0.0;
	let mut f32a: f32 = 0.0;
	let mut f32b: f32 = 0.0;
	let mut f32c: f32 = 0.0;
	let mut f32d: f32 = 0.0;
	let mut i32a: c_int = 0;
	let mut i32b: c_int = 0;
	let mut i32c: c_int = 0;
	let mut i64a: i64 = 0;
	let mut i64b: i64 = 0;

	// Empty-handle boxes (non-NULL pointers wrapping CHandle::null()).
	let node = empty_node_box();
	let project = Box::into_raw(Box::new(OakEngineProject {
		handle: CHandle::null(),
	}));
	let keyframe = Box::into_raw(Box::new(OakEngineKeyframe {
		handle: CHandle::null(),
	}));
	let dragger = Box::into_raw(Box::new(OakEngineNodeDragger {
		handle: CHandle::null(),
	}));
	let footage = Box::into_raw(Box::new(OakEngineFootage {
		handle: CHandle::null(),
	}));

	// project family
	assert_eq!(unsafe { oakengine_project_new(project) }, E_INVALID);
	assert_eq!(
		unsafe { oakengine_project_is_modified(project) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_project_set_modified(project, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_name(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_filename(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_pretty_filename(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_set_filename(project, c"/x.ove".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_cache_path(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_cache_alongside_path(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_set_custom_cache_path(project, c"/x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_get_custom_cache_path(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_get_cache_location_setting(project) },
		-1,
		"NULL → -1 documented"
	);
	assert_eq!(
		unsafe { oakengine_project_get_color_reference_space(project, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_set_color_reference_space(project, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_footage_count(project) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_project_footage_filename(project, 0, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_footage_is_online(project, 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_sequence_count(project) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_project_sequence_at(project, 0) }.is_null());
	assert_eq!(
		unsafe { oakengine_project_node_count(project) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_project_node_at(project, 0) }.is_null());
	assert!(unsafe { oakengine_project_root(project) }.is_null());
	assert!(unsafe { oakengine_project_from_object(node) }.is_null());
	assert_eq!(
		unsafe { oakengine_project_save(project, c"/x.ove".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_project_load(project, c"/x.ove".as_ptr(), buf.as_mut_ptr(), 512) },
		E_INVALID
	);

	// folder family
	assert!(unsafe { oakengine_folder_create(project, node, c"x".as_ptr()) }.is_null());
	assert_eq!(
		unsafe { oakengine_folder_has_child_recursive(node, node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_folder_index_of_child(node, node) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_folder_item_child_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_folder_item_child(node, 0) }.is_null());
	assert_eq!(unsafe { oakengine_folder_add_child(node, node) }, E_INVALID);
	assert!(unsafe { oakengine_folder_remove_element_command(node, node) }.is_null());
	assert_eq!(
		unsafe { oakengine_folder_move_child(node, node) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_folder_move_children(std::ptr::null_mut(), 1, node, c"x".as_ptr()) },
		E_INVALID
	);

	// node factory / metadata / params
	assert!(unsafe { oakengine_node_factory_create_from_id(c"x".as_ptr()) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_category_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(unsafe { oakengine_node_category_at(node, 0) }, -1);
	// Empty handle and NULL both report 0 flags (no error sentinel leaks
	// through as u64::MAX).
	assert_eq!(unsafe { oakengine_node_get_flags(node) }, 0);
	assert_eq!(
		unsafe { oakengine_node_get_sub_category(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_description(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert!(unsafe { oakengine_node_create_copy(node) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_get_type_id(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_name(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_short_name(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_label(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_label(node, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_label_ex(node, c"x".as_ptr(), 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_label_and_name(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_color_label(node) },
		-1,
		"NULL → -1 documented"
	);
	assert_eq!(
		unsafe { oakengine_node_get_effective_color_label(node) },
		-1
	);
	assert!(unsafe { oakengine_node_set_color_label_command(node, 0) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_input_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_id(node, 0, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_get_type(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_connected(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_connectable(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_keyframable(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_keyframed(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_keyframed_ex(node, c"x".as_ptr(), 0) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_array(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_array_size(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_get_flags(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_input_get_data_type(node, c"x".as_ptr()) },
		-1
	);
	assert_eq!(
		unsafe { oakengine_node_input_is_hidden(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_get_input(node, c"x".as_ptr(), &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_input(node, c"x".as_ptr(), &float_value(1.0)) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_input_string(node, c"x".as_ptr(), buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_input_string(node, c"x".as_ptr(), c"s".as_ptr()) },
		E_INVALID
	);
	assert!(
		unsafe {
			oakengine_node_set_standard_value_command(
				node,
				c"x".as_ptr(),
				-1,
				-1,
				&float_value(1.0),
			)
		}
		.is_null(),
		"stub-null"
	);
	assert!(
		unsafe {
			oakengine_node_set_input_video_params_command(node, c"x".as_ptr(), &unsafe {
				std::mem::zeroed::<OakVideoParamsPod>()
			})
		}
		.is_null(),
		"stub-null"
	);
	assert!(
		unsafe {
			oakengine_node_set_value_at_time_command(
				node as *mut c_void,
				c"x".as_ptr(),
				-1,
				0,
				1,
				&float_value(1.0),
				-1,
				0,
			)
		}
		.is_null(),
		"empty handle"
	);
	assert_eq!(
		unsafe { oakengine_node_frame_time_base(node, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_set_input_at_time(node, c"x".as_ptr(), -1, 0, -1, &float_value(1.0), 0)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_input_at_time(node, c"x".as_ptr(), -1, -1, 0, 0, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_set_input_string_at_time(node, c"x".as_ptr(), -1, 0, c"s".as_ptr())
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_get_input_string_at_time(
				node,
				c"x".as_ptr(),
				-1,
				0,
				-1,
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_get_input_bezier_at_time(
				node,
				c"x".as_ptr(),
				-1,
				0,
				-1,
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_get_input_binary_at_time(
				node,
				c"x".as_ptr(),
				-1,
				0,
				-1,
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_array_insert_at(node, c"x".as_ptr(), 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_array_remove_at(node, c"x".as_ptr(), 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_has_property(node, c"x".as_ptr(), c"k".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_set_input_property_string(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				c"v".as_ptr(),
				0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_string(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_number(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				0,
				&mut f64a,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_int(node, c"x".as_ptr(), c"k".as_ptr(), &mut num)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_rational(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				std::ptr::null_mut(),
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_track_number(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				0,
				&mut f64a,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_get_property_count(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_key(node, c"x".as_ptr(), 0, buf.as_mut_ptr(), 512)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_string_list_count(node, c"x".as_ptr(), c"k".as_ptr())
		},
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_get_property_string_list(
				node,
				c"x".as_ptr(),
				c"k".as_ptr(),
				0,
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_get_default_value(node, c"x".as_ptr(), 0, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_input_name(node, c"x".as_ptr(), buf.as_mut_ptr(), 512) },
		E_INVALID
	);

	// graph editing
	assert_eq!(
		unsafe { oakengine_node_connect(node, node, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_disconnect(node, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_disconnect_ex(node, c"x".as_ptr(), -1) },
		E_INVALID
	);
	assert!(unsafe { oakengine_node_connect_command(node, node, c"x".as_ptr(), -1) }.is_null());
	assert!(unsafe { oakengine_node_disconnect_command(node, c"x".as_ptr(), -1) }.is_null());
	assert_eq!(unsafe { oakengine_node_copy_inputs(node, node) }, E_INVALID);
	assert!(unsafe { oakengine_node_copy_in_graph(node, std::ptr::null_mut()) }.is_null());
	assert!(unsafe { oakengine_node_input_get_connected_node(node, c"x".as_ptr(), -1) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_output_connection_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_output_connection_at(
				node,
				0,
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_output_connection_at_ex(
				node,
				0,
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				std::ptr::null_mut(),
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_connection_count_all(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_input_connection_at_all(
				node,
				0,
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				std::ptr::null_mut(),
				std::ptr::null_mut(),
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_input_connection_count(node, c"x".as_ptr(), -1) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_node_input_connection_at(node, c"x".as_ptr(), -1, 0) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_inputs_from(node, node, 1) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_set_value_hint(node, c"x".as_ptr(), 0, 0, 0, c"".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_context_position(node, node, 0.0, 0.0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_context_position(node, node, &mut f64a, &mut f64b, &mut i32a) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_set_context_expanded(node, node, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_context_node_count(node) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_context_contains_node(node, node) },
		E_INVALID
	);
	assert!(
		unsafe { oakengine_node_context_node_at(node, 0, &mut f64a, &mut f64b, &mut i32a) }
			.is_null()
	);
	assert_eq!(
		unsafe { oakengine_node_get_effect_input(node, buf.as_mut_ptr(), 512, &mut i32a) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_count(node, c"x".as_ptr()) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_count_on_track(node, c"x".as_ptr(), 0, 0) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_at(node, c"x".as_ptr(), 0, &mut num, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_get_easing(
				node,
				c"x".as_ptr(),
				0,
				&mut f32a,
				&mut f32b,
				&mut f32c,
				&mut f32d,
				&mut i32a,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_add(
				node,
				c"x".as_ptr(),
				0,
				&float_value(1.0),
				0,
				0.0,
				0.0,
				0.0,
				0.0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_remove(node, c"x".as_ptr(), 0) },
		E_INVALID
	);
	assert!(unsafe {
		oakengine_node_insert_keyframe_command(
			node,
			c"x".as_ptr(),
			-1,
			0,
			0,
			&float_value(1.0),
			0,
			0.0,
			0.0,
			0.0,
			0.0,
		)
	}
	.is_null());
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_set_easing(node, c"x".as_ptr(), 0, 0, 0.0, 0.0, 0.0, 0.0)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_set_type_many(
				node,
				c"x".as_ptr(),
				-1,
				std::ptr::null(),
				std::ptr::null(),
				0,
				0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_set_time_many(
				node,
				c"x".as_ptr(),
				-1,
				std::ptr::null(),
				std::ptr::null(),
				0,
				0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_set_value_many(
				node,
				c"x".as_ptr(),
				-1,
				std::ptr::null(),
				std::ptr::null(),
				0,
				std::ptr::null(),
				std::ptr::null(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_set_bezier_many(
				node,
				c"x".as_ptr(),
				-1,
				std::ptr::null(),
				std::ptr::null(),
				0,
				0.0,
				0.0,
				0.0,
				0.0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_set_bezier_point(
				node,
				c"x".as_ptr(),
				-1,
				0,
				0,
				0,
				0.0,
				0.0,
				0.0,
				0.0,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_keyframes_clear(node, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_best_type_at_time(node, c"x".as_ptr(), -1, 0, 0, 5) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_track_count(node, c"x".as_ptr(), -1) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_toggle_at_time(node, c"x".as_ptr(), -1, 0, 0, 1, c"t".as_ptr())
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_has_keyframe_at_time(node, c"x".as_ptr(), -1, 0, 0) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_earliest_time(node, c"x".as_ptr(), -1, &mut num, &mut den)
		},
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_keyframe_latest_time(node, c"x".as_ptr(), -1, &mut num, &mut den) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_closest_time_before(
				node,
				c"x".as_ptr(),
				-1,
				0,
				0,
				&mut num,
				&mut den,
			)
		},
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframe_closest_time_after(
				node,
				c"x".as_ptr(),
				-1,
				0,
				0,
				&mut num,
				&mut den,
			)
		},
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(
		unsafe { oakengine_node_keyframe_handle_on_track(node, c"x".as_ptr(), -1, 0, 0) }.is_null()
	);
	assert!(
		unsafe { oakengine_node_keyframe_handle_at_time(node, c"x".as_ptr(), -1, 0, 0, 1) }
			.is_null()
	);
	assert_eq!(
		unsafe {
			oakengine_node_keyframes_at_time(node, c"x".as_ptr(), -1, 0, 1, std::ptr::null_mut(), 0)
		},
		0,
		"stub ignores its handle"
	);
	assert_eq!(
		unsafe {
			oakengine_node_set_input_keyframing(node, c"x".as_ptr(), -1, 1, 0, 0, c"k".as_ptr())
		},
		E_INVALID
	);
	assert!(
		unsafe { oakengine_node_set_input_keyframing_command(node, c"x".as_ptr(), -1, 1) }
			.is_null()
	);
	assert_eq!(
		unsafe { oakengine_node_keyframes_paste(node, std::ptr::null_mut(), 1, c"p".as_ptr()) },
		E_INVALID
	);

	// keyframe handle family
	assert_eq!(
		unsafe { oakengine_keyframe_get_time(keyframe, &mut num, &mut den) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_get_input_id(keyframe, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(unsafe { oakengine_keyframe_get_track(keyframe) }, -1);
	assert_eq!(unsafe { oakengine_keyframe_get_element(keyframe) }, -1);
	assert!(unsafe { oakengine_keyframe_get_node(keyframe) }.is_null());
	assert_eq!(unsafe { oakengine_keyframe_get_type(keyframe) }, -1);
	assert_eq!(
		unsafe { oakengine_keyframe_get_value(keyframe, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_compute_paste_value(node, keyframe, &mut out) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_has_sibling_at_time(keyframe, 0, 0) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_keyframe_set_bezier_point_live(keyframe, 0, 0.0, 0.0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_get_bezier_point(keyframe, 0, &mut f64a, &mut f64b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_get_valid_bezier_point(keyframe, 0, &mut f64a, &mut f64b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_set_value_live(keyframe, &float_value(1.0)) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_keyframe_set_time_live(keyframe, 1, 1) },
		E_INVALID
	);
	assert!(unsafe { oakengine_keyframe_set_time_command(keyframe, 1) }.is_null());
	assert!(unsafe { oakengine_keyframe_set_value_command(keyframe, &float_value(1.0)) }.is_null());
	assert!(
		unsafe {
			oakengine_keyframe_create(node, c"x".as_ptr(), -1, 0, 0, 0, &float_value(1.0), 0)
		}
		.is_null(),
		"empty node"
	);
	assert!(unsafe {
		oakengine_keyframe_create(
			std::ptr::null_mut(),
			c"x".as_ptr(),
			-1,
			0,
			0,
			0,
			&float_value(1.0),
			0,
		)
	}
	.is_null());

	// dragger family
	assert!(
		unsafe { oakengine_dragger_create(node, c"x".as_ptr(), -1, 1) }.is_null(),
		"empty node"
	);
	assert_eq!(
		unsafe { oakengine_dragger_start(dragger, 0, 1, 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_dragger_drag(dragger, &float_value(1.0)) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_dragger_end(dragger, c"x".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_dragger_is_started(dragger) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);

	// group family
	assert_eq!(
		unsafe { oakengine_group_input_passthrough_count(node) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_group_add_input_passthrough(
				node,
				node,
				c"x".as_ptr(),
				-1,
				c"".as_ptr(),
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_group_input_passthrough_at(
				node,
				0,
				buf.as_mut_ptr(),
				512,
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				&mut i32a,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_group_get_id_of_passthrough(
				node,
				node,
				c"x".as_ptr(),
				-1,
				buf.as_mut_ptr(),
				512,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_group_get_passthrough_from_id(
				node,
				c"id".as_ptr(),
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				&mut i32a,
			)
		},
		E_INVALID
	);
	assert!(unsafe { oakengine_group_get_output_passthrough(node) }.is_null());
	assert_eq!(
		unsafe { oakengine_group_set_output_passthrough(node, node) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_group_resolve_input(
				node,
				c"x".as_ptr(),
				-1,
				std::ptr::null_mut(),
				buf.as_mut_ptr(),
				512,
				&mut i32a,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_group_remove_input_passthrough(node, node, c"x".as_ptr(), -1) },
		E_INVALID
	);
	assert!(unsafe {
		oakengine_group_add_input_passthrough_command(node, node, c"x".as_ptr(), -1, c"".as_ptr())
	}
	.is_null());
	assert!(unsafe { oakengine_group_set_output_passthrough_command(node, node) }.is_null());
	assert_eq!(
		unsafe {
			oakengine_group_add_input_passthrough_undoable(
				node,
				node,
				c"x".as_ptr(),
				-1,
				c"".as_ptr(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_group_set_output_passthrough_undoable(node, node) },
		E_INVALID
	);

	// multicam family
	assert_eq!(
		unsafe { oakengine_multicam_get_source_count(node) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_multicam_get_current_source(node) },
		E_INVALID
	);

	// subtree / caches / data
	assert_eq!(
		unsafe { oakengine_node_has_gizmos(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_gizmo_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_node_gizmo_at(node, 0) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_update_gizmo_positions(node, std::ptr::null_mut(), 0, 0, 0, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_data(node, 0, &mut i32a, &mut num, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_get_exclusive_dependency_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_node_get_exclusive_dependency_at(node, 0) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_has_plugin(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_plugin_message_count(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_plugin_message_at(node, 0, &mut i32a, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_node_plugin_clear_messages(node) },
		E_INVALID
	);
	assert!(unsafe { oakengine_node_get_thumbnail_cache(node) }.is_null());
	assert!(unsafe { oakengine_node_get_waveform_cache(node) }.is_null());
	assert!(unsafe { oakengine_node_get_video_frame_cache(node) }.is_null());
	assert_eq!(
		unsafe { oakengine_node_is_clip(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_track(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_viewer_output(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_footage(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_sequence(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_folder(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_group(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_multicam(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_node_is_item(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert!(unsafe { oakengine_node_get_project(node) }.is_null());
	assert!(unsafe { oakengine_node_parent(node) }.is_null());
	assert!(unsafe { oakengine_node_folder(node) }.is_null());
	assert!(unsafe { oakengine_clip_get_track(node) }.is_null());
	assert_eq!(unsafe { oakengine_track_get_type(node) }, -1);
	assert_eq!(unsafe { oakengine_track_get_index(node) }, -1);
	assert!(unsafe { oakengine_track_get_sequence(node) }.is_null());
	assert_eq!(
		unsafe { oakengine_block_get_length_rational(node, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_block_get_in_rational(node, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_block_get_out_rational(node, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert!(unsafe { oakengine_viewer_output_get_connected_texture(node) }.is_null());
	assert_eq!(
		unsafe {
			oakengine_shape_set_rect_undoable(
				node,
				0.0,
				0.0,
				1.0,
				1.0,
				&unsafe { std::mem::zeroed::<OakVideoParamsPod>() },
				std::ptr::null_mut(),
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_subtitle_get_text(node, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_subtitle_set_text(node, c"x".as_ptr()) },
		E_INVALID
	);

	// footage family
	assert!(
		unsafe { oakengine_footage_borrow(node) }.is_null(),
		"not a footage node"
	);
	assert_eq!(
		unsafe { oakengine_footage_is_valid(node) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_footage_get_decoder_name(footage, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_video_stream_count(footage) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_footage_get_audio_stream_count(footage) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_footage_get_subtitle_stream_count(footage) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_footage_get_duration(footage, &mut f64a) },
		E_INVALID
	);
	assert_eq!(unsafe { oakengine_footage_is_online(footage) }, E_INVALID);
	assert_eq!(
		unsafe { oakengine_footage_get_source_start_time(footage, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_relink(footage, c"/x.mp4".as_ptr()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_get_state(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_generate(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_delete(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_is_enabled(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_set_enabled(footage, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_proxy_get_path(footage, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_filename(footage, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_colorspace_count(footage) },
		E_INVALID,
		"empty handle, not a NULL pointer"
	);
	assert_eq!(
		unsafe { oakengine_footage_colorspace_at(footage, 0, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_has_custom_proxy_params(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_effective_proxy_params(footage, std::ptr::null_mut()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_custom_proxy_params(footage, std::ptr::null()) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_clear_custom_proxy_params(footage) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_proxy(footage, c"/x.mp4".as_ptr(), 0, 0, 0, 1) },
		E_INVALID
	);
	assert_eq!(unsafe { oakengine_footage_clear_proxy(footage) }, E_INVALID);
	assert_eq!(unsafe { oakengine_footage_invalidate(footage) }, E_INVALID);
	assert_eq!(
		unsafe { oakengine_footage_set_source_start_time(footage, 1, 0, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_source_start_time_source(footage, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_stream_enabled(footage, 0, 0, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_stream_enabled(footage, 0, 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_stream_reference(footage, 0, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_describe_video_stream(footage, 0, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_describe_audio_stream(footage, 0, buf.as_mut_ptr(), 512) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_footage_get_video_stream_overrides(
				footage,
				0,
				buf.as_mut_ptr(),
				512,
				&mut i32a,
				&mut i32b,
				&mut i32c,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_video_stream_overrides(footage, 0, c"".as_ptr(), 0, 0, 0) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_get_pixel_aspect(footage, 0, &mut i32a, &mut i32b) },
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_pixel_aspect(footage, 0, 1, 1) },
		E_INVALID
	);
	assert_eq!(
		unsafe {
			oakengine_footage_get_image_sequence_params(
				footage, 0, &mut i64a, &mut i64b, &mut i32a, &mut i32b,
			)
		},
		E_INVALID
	);
	assert_eq!(
		unsafe { oakengine_footage_set_image_sequence_params(footage, 0, 0, 1, 25, 1) },
		E_INVALID
	);
	assert!(
		unsafe { oakengine_project_import_footage(project, c"/x.mp4".as_ptr()) }.is_null(),
		"empty project"
	);
	assert_eq!(
		unsafe { oakengine_project_find_offline_footage(project, c"/tmp".as_ptr()) },
		E_INVALID
	);

	// buffer-size edge cases: NULL buf / zero / negative size never crash.
	let mut small = [0 as c_char; 4];
	assert_eq!(
		unsafe { oakengine_node_get_type_id(node, small.as_mut_ptr(), 4) },
		E_INVALID
	); // empty handle wins
	let _ = unsafe { oakengine_node_last_error(std::ptr::null_mut(), 0) };
	let _ = unsafe { oakengine_node_last_error(std::ptr::null_mut(), -5) };
	let _ = unsafe { oakengine_footage_last_error(std::ptr::null_mut(), 0) };
	let _ = unsafe { oakengine_footage_last_error(small.as_mut_ptr(), -1) };
	// Two-stage getters with a NULL buf only report the length (legal).
	let _ = unsafe { oakengine_node_category_name(0, std::ptr::null_mut(), 0) };

	// Free the empty boxes (no-op release paths).
	unsafe { oakengine_node_free(node) };
	unsafe { oakengine_project_free(project) };
	unsafe { oakengine_keyframe_dispose(keyframe) };
	unsafe { oakengine_dragger_free(dragger) };
	unsafe { oakengine_footage_free(footage) };
}

// ---------------------------------------------------------------------------
// Module destroy contracts + alive counter
// ---------------------------------------------------------------------------

/// Facade `free`/`dispose`/NULL/empty contracts plus the module destroy
/// paths they delegate to: `free(NULL)` and `free(empty)` are no-ops, the
/// module-level free of an already-emptied handle is double-free-safe, and
/// every owned-object round trip restores the debug alive counter.
#[test]
fn destroy_contracts_and_alive_count() {
	with_owned(|| {
		common::force_link();
		let _ = force_oakundo_command_link();
		let base = alive();

		// Facade-level free(NULL) / free(empty box) are no-ops.
		unsafe { oakengine_project_free(std::ptr::null_mut()) };
		unsafe { oakengine_node_free(std::ptr::null_mut()) };
		unsafe { oakengine_keyframe_dispose(std::ptr::null_mut()) };
		unsafe { oakengine_dragger_free(std::ptr::null_mut()) };
		unsafe { oakengine_footage_free(std::ptr::null_mut()) };

		// Owned round trips: create +1, free back to baseline.
		let project = oakengine_project_create();
		assert!(!project.is_null());
		assert_eq!(alive(), base + 1);
		unsafe { oakengine_project_free(project) };
		assert_eq!(alive(), base, "project free must return the alive counter");

		let node = unsafe { oakengine_node_factory_create_from_id(TYPE_VALUE.as_ptr()) };
		assert!(!node.is_null());
		assert_eq!(alive(), base + 1);
		unsafe { oakengine_node_free(node) };
		assert_eq!(alive(), base);

		let group = unsafe { oakengine_node_group_create() };
		assert!(!group.is_null());
		assert_eq!(alive(), base + 1);
		unsafe { oakengine_node_free(group) };
		assert_eq!(alive(), base);

		// Module-level double-free of an already-emptied handle is a no-op
		// (the destroy path the facade wraps clears ctx before returning).
		let mut h = unsafe { oaknode_factory_create_from_id(TYPE_VALUE.as_ptr()) };
		assert!(!h.is_null());
		assert_eq!(alive(), base + 1);
		unsafe { oaknode_node_free(&mut h) };
		assert!(h.is_null());
		unsafe { oaknode_node_free(&mut h) }; // double free: no-op
		assert_eq!(alive(), base);

		let mut ph = unsafe { oakengine::oaknode::ffi::project::oaknode_project_init() };
		assert!(!ph.is_null());
		assert_eq!(alive(), base + 1);
		unsafe { oaknode_project_free(&mut ph) };
		assert!(ph.is_null());
		unsafe { oaknode_project_free(&mut ph) }; // double free: no-op
		assert_eq!(alive(), base);

		// Keyframe handles are not alive-counted but their free is
		// double-free-safe at the module level.
		let mut kh = unsafe {
			oaknode_kf_create(
				0,
				1,
				&float_value_direct(1.0),
				0,
				0,
				-1,
				c"value_in".as_ptr(),
				CHandle::null(),
			)
		};
		assert!(!kh.is_null());
		unsafe { oaknode_keyframe_free(&mut kh) };
		assert!(kh.is_null());
		unsafe { oaknode_keyframe_free(&mut kh) }; // double free: no-op
		assert_eq!(alive(), base);

		// Dragger module free: create against a real node handle (freed
		// separately), then double-free the dragger handle.
		let mut nh = unsafe { oaknode_factory_create_from_id(TYPE_VALUE.as_ptr()) };
		assert!(!nh.is_null());
		let mut dh = unsafe {
			oakengine::oaknode::ffi::dragger::oaknode_dragger_create(nh, c"value_in".as_ptr(), -1, 0)
		};
		assert!(!dh.is_null());
		unsafe { oaknode_node_free(&mut nh) };
		unsafe { oaknode_dragger_free(&mut dh) };
		assert!(dh.is_null());
		unsafe { oaknode_dragger_free(&mut dh) }; // double free: no-op
		assert_eq!(alive(), base);
	});
}

/// `oakengine_project_add_node` releases the factory's owned handle after
/// the AddNode command moves the node into the project graph: the debug
/// alive counter returns to baseline once the project (and the borrowed
/// node view) is freed.
#[test]
fn project_add_node_owned_handle_leak() {
	with_owned(|| {
		common::force_link();
		let _ = force_oakundo_command_link();
		let base = alive();

		let project = oakengine_project_create();
		assert_eq!(alive(), base + 1);

		let node = unsafe { oakengine_project_add_node(project, TYPE_VALUE.as_ptr()) };
		assert!(!node.is_null());
		// The added-node view is borrowed; the factory's owned handle was
		// released by the facade, so only the project is alive-counted.
		assert_eq!(
			alive(),
			base + 1,
			"project only; add_node returns a borrowed view"
		);

		// Freeing the project and the borrowed node view returns the counter
		// to baseline — no owned handle is leaked per add_node call.
		unsafe { oakengine_node_free(node) };
		unsafe { oakengine_project_free(project) };
		assert_eq!(
			alive(),
			base,
			"no leak: the owned factory handle was released"
		);
	});
}

// ---------------------------------------------------------------------------
// Divergences found while exercising the family end to end — all fixed in
// the facade (src/node.rs); each item below states the fixed behavior.
// ---------------------------------------------------------------------------
//
// 1. `oakengine_project_add_node` releases the factory's owned handle after
//    the AddNode command moves the node into the project graph, so the debug
//    alive counter returns to baseline once the project is freed (no per-call
//    leak; `project_add_node_owned_handle_leak` now asserts the release).
//
// 2. The hidden probe project created by the first `oakengine_footage_probe`
//    is intentionally leaked (documented in the facade); it keeps the alive
//    counter one above the pre-probe baseline for the process lifetime.
//
// 3. `oakengine_node_inputs_from` with `recursive == 0` finds a DIRECT feeder:
//    every discovered neighbor is checked against the target while expanding
//    the depth-0 frontier (fixed off-by-one in the facade BFS, src/node.rs
//    `inputs_from`).
//
// 4. `oakengine_group_get_id_of_passthrough`, `oakengine_group_get_passthrough_from_id`
//    and `oakengine_group_resolve_input` treat the module's two-stage string
//    length (>= 0, e.g. 9 for "value_in") as a SUCCESS, only negative codes as
//    failures. `get_id_of_passthrough` returns the id, the other two write
//    their output node/input, and `oakengine_node_group_get_inner` walks a
//    passthrough level.
//
// 5. `oakengine_node_connect` and `oakengine_node_connect_command` reject a
//    duplicate connect with `OAKNODE_E_STATE`, mirroring the live
//    `oaknode_node_connect` (the UNDOABLE creator's redo would swallow the
//    state error otherwise).
//
// 6. `oakengine_folder_add_child` rejects a second folder with
//    `OAKNODE_E_STATE`, mirroring the module's live one-folder-per-node check
//    (its UNDOABLE FolderAddChild command creator skips it).
//
// 7. `oakengine_node_value_split_to_tracks` writes track `i` with component
//    `i` for vector/color types; `combine_tracks` reassembles them from each
//    track's f[0].
//
// 8. Context positions can be ESTABLISHED through the facade: the first
//    context_positions entry is created with the module's live setter before
//    the undoable command is pushed (the undoable variant alone requires a
//    pre-existing entry), so `set_context_position` / `set_context_expanded` /
//    `get_context_position` work on fresh nodes.
//
// 9. `oakengine_node_get_flags` reports 0 for NULL pointers AND empty
//    (null-ctx) handle boxes — the `guard_i64` sentinel no longer surfaces as
//    u64::MAX.
//
// 10. `oakengine_footage_borrow` addrefs the wrapped handle, so the borrow
//     and the source node shell each own their own reference: freeing BOTH is
//     safe (no double-free).
// ---------------------------------------------------------------------------