-- Isolated M2 hearth process tests; pass mods/hearth/processes.lua as argument.
assert(arg and arg[1], "Pass the path to mods/hearth/processes.lua")
local now, game_now = 100000, 500
local protected, claimed, distant, violations = false, true, false, 0
local world, metadata, timers, sounds = {}, {}, {}, {}
local function key(pos) return pos.x .. ":" .. pos.y .. ":" .. pos.z end
local hearth_pos = {x = 0, y = 0, z = 0}

local function stack(text)
	local name, count = (text or ""):match("^(%S+)%s*(%d*)$")
	return setmetatable({name = name or "", count = name and (tonumber(count) or 1) or 0,
		wear = 0}, {
		__index = {
			get_name = function(self) return self.name end,
			get_count = function(self) return self.count end,
			is_empty = function(self) return self.count == 0 end,
			take_item = function(self, amount)
				self.count = math.max(0, self.count - (amount or 1))
				if self.count == 0 then self.name = "" end
			end,
			add_wear = function(self, amount)
				self.wear = self.wear + amount
				if self.wear >= 65535 then self.name, self.count = "", 0 end
			end,
		},
	})
end
ItemStack = stack

local function meta_for(pos)
	local k = key(pos)
	if not metadata[k] then
		local fields = {}
		metadata[k] = {
			set_string = function(_, name, value) fields[name] = tostring(value) end,
			get_string = function(_, name) return fields[name] or "" end,
			set_int = function(_, name, value) fields[name] = math.floor(value) end,
			get_int = function(_, name) return tonumber(fields[name]) or 0 end,
		}
	end
	return metadata[k]
end

local api = {}
function api.get_meta(pos) return meta_for(pos) end
function api.get_node(pos) return world[key(pos)] or {name = "air"} end
function api.swap_node(pos, node) world[key(pos)] = node end
function api.get_gametime() return game_now end
function api.get_node_timer(pos)
	local k = key(pos)
	if not timers[k] then
		timers[k] = {
			start = function(self, timeout) self.timeout = timeout end,
			stop = function(self) self.timeout = nil end,
		}
	end
	return timers[k]
end
function api.sound_play(name, params) sounds[#sounds + 1] = {name = name, params = params} end

local player
local function allowed(pos, who)
	local dx = pos.x - who.position.x
	local dy = pos.y - who.position.y
	local dz = pos.z - who.position.z
	if protected or not claimed or distant or dx * dx + dy * dy + dz * dz > 36 then
		violations = violations + 1
		return false
	end
	return true
end
local construction = {allowed = allowed}
local hearth = {}
function hearth.notify(_, message) hearth.last_notice = message end
local processes = dofile(arg[1])(hearth, api, construction)

local inventory = {room = true, added = {}, reject_next = false}
function inventory:room_for_item(_, item) return self.room and not item:is_empty() end
function inventory:add_item(_, item)
	if self.reject_next then
		self.reject_next = false
		return stack(item:get_name())
	end
	self.added[#self.added + 1] = item:get_name()
	return stack("")
end
player = {position = {x = 0, y = 0, z = 0}}
function player:get_inventory() return inventory end

local real_time = os.time
os.time = function() return now end
local function eq(actual, expected)
	assert(actual == expected, "expected " .. tostring(expected) .. ", got " .. tostring(actual))
end
local passed = 0
local function reset()
	now, game_now = 100000, 500
	protected, claimed, distant, violations = false, true, false, 0
	world, metadata, timers, sounds = {}, {}, {}, {}
	inventory.room, inventory.added, inventory.reject_next = true, {}, false
	player.position = {x = 0, y = 0, z = 0}
	hearth.last_notice = nil
	world[key(hearth_pos)] = {name = "hearth:fire", param2 = 2}
	local meta = api.get_meta(hearth_pos)
	meta:set_int("lit", 0)
	meta:set_string("fuel_until", "0")
end
local function test(name, fn)
	reset()
	local ok, err = pcall(fn)
	if not ok then error(name .. ": " .. tostring(err), 0) end
	passed = passed + 1
	print("ok " .. passed .. " - " .. name)
end
local function use(text)
	local item = stack(text)
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, item)
	return item
end
local function starter(item, pos)
	return processes.use_firestarter(item, player, {type = "node", under = pos or hearth_pos})
end
local function deadline(pos)
	return tonumber(api.get_meta(pos or hearth_pos):get_string("fuel_until")) or 0
end
local function advance(seconds)
	now, game_now = now + seconds, game_now + seconds
	local timer = api.get_node_timer(hearth_pos)
	if timer.timeout then
		timer.timeout = timer.timeout - seconds
		if timer.timeout <= 0 then processes.fire_tick(hearth_pos) end
	end
end

test("fuel does not ignite itself and a firestarter is reusable", function()
	local firestarter = stack("hearth:firestarter")
	starter(firestarter)
	eq(firestarter.wear, 0)
	eq(api.get_node(hearth_pos).name, "hearth:fire")
	eq(use("hearth:sticks"):get_count(), 0)
	eq(api.get_node(hearth_pos).name, "hearth:fire")
	eq(api.get_meta(hearth_pos):get_int("lit"), 0)
	starter(firestarter)
	eq(api.get_node(hearth_pos).name, "hearth:fire_lit")
	eq(firestarter.wear, math.ceil(65535 / 20))
	local second = {x = 1, y = 0, z = 0}
	world[key(second)] = {name = "hearth:fire", param2 = 0}
	api.get_meta(second):set_int("lit", 0)
	api.get_meta(second):set_string("fuel_until", "0")
	processes.use_fire(second, api.get_node(second), player, stack("hearth:sticks"))
	starter(firestarter, second)
	eq(firestarter.wear, math.ceil(65535 / 20) * 2)
	for _ = 3, 20 do
		local meta = api.get_meta(hearth_pos)
		meta:set_int("lit", 0)
		processes.refresh_fire(hearth_pos, processes.fuel_left(hearth_pos, now), now)
		starter(firestarter)
	end
	eq(firestarter.wear, math.ceil(65535 / 20) * 20)
	eq(firestarter:is_empty(), true)
	eq(#sounds, 20)
	eq(sounds[1].name, "hearth_fire")
end)

test("cooking waits six real seconds and reserves the heat cost at start", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	local input = use("hearth:raw_food 2")
	eq(input:get_count(), 1)
	eq(api.get_meta(hearth_pos):get_int("job_until"), now + 6)
	eq(api.get_meta(hearth_pos):get_int("job_cost"), 20)
	eq(deadline(), now + 25)
	eq(api.get_node_timer(hearth_pos).timeout, 6)
	advance(5)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "cook")
	eq(deadline(), now + 20)
	advance(1)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "")
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_food")
	eq(deadline(), now + 19)
	processes.fire_tick(hearth_pos)
	eq(deadline(), now + 19)
end)

test("boiling waits four gameplay seconds and charges its own fuel cost", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:water_raw")
	eq(api.get_meta(hearth_pos):get_int("job_until"), now + 4)
	eq(api.get_meta(hearth_pos):get_int("job_cost"), 10)
	advance(3)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "boil")
	eq(deadline(), now + 32)
	advance(1)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:water_clean")
	eq(deadline(), now + 31)
end)

test("process start requires the complete duration-plus-cost fuel reserve", function()
	local meta = api.get_meta(hearth_pos)
	meta:set_int("lit", 1)
	meta:set_string("fuel_until", tostring(now + 25))
	local too_little = use("hearth:raw_food")
	eq(too_little:get_count(), 1)
	eq(meta:get_string("job_kind"), "")
	meta:set_string("fuel_until", tostring(now + 27))
	local enough = use("hearth:raw_food")
	eq(enough:get_count(), 0)
	eq(meta:get_string("job_kind"), "cook")
	advance(6)
	eq(deadline(), now + 1)
	eq(api.get_node(hearth_pos).name, "hearth:fire_lit")
end)

test("inventory rejection preserves completed output until a successful claim", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:raw_food")
	advance(6)
	inventory.room = false
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_food")
	inventory.room, inventory.reject_next = true, true
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_food")
	eq(#inventory.added, 0)
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(api.get_meta(hearth_pos):get_string("job_result"), "")
	eq(#inventory.added, 1)
	eq(inventory.added[1], "hearth:cooked_food")
end)

test("a queued job and pending output block replacement or a second queue", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:raw_food")
	eq(use("hearth:water_raw"):get_count(), 1)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "cook")
	advance(6)
	eq(use("hearth:water_raw"):get_count(), 1)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_food")
end)

test("load reconciliation resumes remaining time and completes overdue jobs once", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:water_raw")
	game_now, now = game_now + 2, now + 2 -- Simulate shutdown without timer callbacks.
	processes.fire_tick(hearth_pos) -- The registered LBM callback.
	eq(api.get_node_timer(hearth_pos).timeout, 2)
	advance(2)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:water_clean")
	local charged = deadline()
	game_now, now = game_now + 20, now + 20
	processes.fire_tick(hearth_pos)
	processes.fire_tick(hearth_pos)
	eq(deadline(), charged)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:water_clean")
end)

test("charcoal sustains M4 iron-smelting charges and produces one ingot", function()
	use("hearth:charcoal")
	starter(stack("hearth:firestarter"))
	local charge = use("hearth:smelt_charge")
	eq(charge:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "smelt")
	eq(deadline(), now + 60)
	advance(60)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:iron_ingot")
	use("")
	eq(inventory.added[1], "hearth:iron_ingot")
	eq(api.get_meta(hearth_pos):get_string("job_result"), "")
end)

for _, species in ipairs({"oak", "birch", "pine", "willow", "alder", "beech", "aspen", "rowan", "hazel", "spruce"}) do
	test(species .. " logs fuel directly for 180 seconds without ignition or overflow", function()
		eq(use("hearth:" .. species .. "_log 2"):get_count(), 1)
		eq(deadline(), now + 180)
		eq(api.get_meta(hearth_pos):get_int("lit"), 0)
		use("hearth:" .. species .. "_log")
		use("hearth:" .. species .. "_log")
		eq(deadline(), now + 540)
		eq(use("hearth:" .. species .. "_log"):get_count(), 1)
		eq(deadline(), now + 540)
	end)
end

test("coal adds 240 seconds and rejects overflow without consuming an item", function()
	eq(use("hearth:coal 3"):get_count(), 2)
	eq(deadline(), now + 240)
	eq(api.get_meta(hearth_pos):get_int("lit"), 0)
	use("hearth:coal")
	eq(deadline(), now + 480)
	eq(use("hearth:coal"):get_count(), 1)
	eq(deadline(), now + 480)
	advance(120)
	eq(use("hearth:coal"):get_count(), 0)
	eq(processes.fuel_left(hearth_pos, now), 600)
	eq(use("hearth:sticks"):get_count(), 1)
end)

test("coal fuels copper smelting for 45 seconds with 30 reserved and one ingot", function()
	use("hearth:coal")
	starter(stack("hearth:firestarter"))
	eq(use("hearth:copper_charge 2"):get_count(), 1)
	local meta = api.get_meta(hearth_pos)
	eq(meta:get_string("job_kind"), "smelt_copper")
	eq(meta:get_int("job_until"), now + 45)
	eq(meta:get_int("job_cost"), 30)
	eq(deadline(), now + 210)
	eq(api.get_node_timer(hearth_pos).timeout, 45)
	assert(meta:get_string("infotext"):find("smelting copper", 1, true))
	advance(44)
	eq(meta:get_string("job_kind"), "smelt_copper")
	eq(use(""):get_count(), 0)
	eq(#inventory.added, 0)
	advance(1)
	eq(meta:get_string("job_kind"), "")
	eq(meta:get_string("job_result"), "hearth:copper_ingot")
	eq(processes.fuel_left(hearth_pos, now), 165)
	use(""); use(""); processes.fire_tick(hearth_pos)
	eq(#inventory.added, 1)
	eq(inventory.added[1], "hearth:copper_ingot")
	eq(meta:get_string("job_result"), "")
end)

test("copper needs ignition and exactly duration plus cost before consuming its charge", function()
	use("hearth:coal")
	eq(use("hearth:copper_charge"):get_count(), 1)
	starter(stack("hearth:firestarter"))
	local meta = api.get_meta(hearth_pos)
	meta:set_string("fuel_until", tostring(now + 74))
	eq(use("hearth:copper_charge"):get_count(), 1)
	eq(meta:get_string("job_kind"), "")
	eq(deadline(), now + 74)
	meta:set_string("fuel_until", tostring(now + 75))
	eq(use("hearth:copper_charge"):get_count(), 0)
	eq(deadline(), now + 45)
	advance(45)
	eq(meta:get_string("job_result"), "hearth:copper_ingot")
	eq(processes.fuel_left(hearth_pos, now), 0)
end)

test("copper reload resumes then completes long-offline output idempotently", function()
	use("hearth:pine_log")
	starter(stack("hearth:firestarter"))
	use("hearth:copper_charge")
	local charged = deadline()
	now = now + 20 -- No timer callback while unloaded.
	local reloaded = dofile(arg[1])(hearth, api, construction)
	reloaded.fire_tick(hearth_pos)
	eq(api.get_node_timer(hearth_pos).timeout, 25)
	eq(deadline(), charged)
	now = now + 86400 * 30
	for _ = 1, 3 do reloaded.fire_tick(hearth_pos) end
	local meta = api.get_meta(hearth_pos)
	eq(meta:get_string("job_result"), "hearth:copper_ingot")
	eq(meta:get_int("job_cost"), 0)
	eq(meta:get_string("job_kind"), "")
	eq(api.get_node(hearth_pos).name, "hearth:fire")
	eq(use("hearth:copper_charge"):get_count(), 1) -- Pending output cannot be overwritten.
	eq(use("hearth:smelt_charge"):get_count(), 1)
	use("")
	reloaded.fire_tick(hearth_pos); use("")
	eq(#inventory.added, 1)
	eq(inventory.added[1], "hearth:copper_ingot")
end)

test("full inventory and insertion rejection retain copper until exactly one collection", function()
	use("hearth:coal"); starter(stack("hearth:firestarter")); use("hearth:copper_charge")
	eq(use("hearth:copper_charge"):get_count(), 1)
	eq(use("hearth:smelt_charge"):get_count(), 1)
	advance(45)
	inventory.room = false
	use("")
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:copper_ingot")
	inventory.room, inventory.reject_next = true, true
	use("")
	eq(#inventory.added, 0)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:copper_ingot")
	use(""); use("")
	eq(#inventory.added, 1)
	eq(inventory.added[1], "hearth:copper_ingot")
end)

test("authorization blocks new fuels copper queue and copper output before mutation", function()
	local function deny(mode)
		protected, claimed, distant = mode == "protected", mode ~= "claim", mode == "distance"
	end
	for _, mode in ipairs({"protected", "claim", "distance"}) do
		deny(mode)
		for _, fuel in ipairs({"coal", "oak_log", "birch_log", "pine_log", "willow_log", "alder_log",
			"beech_log", "aspen_log", "rowan_log", "hazel_log", "spruce_log"}) do
			eq(use("hearth:" .. fuel):get_count(), 1)
		end
		eq(deadline(), 0)
		eq(starter(stack("hearth:firestarter")).wear, 0)
	end
	protected, claimed, distant = false, true, false
	use("hearth:coal"); starter(stack("hearth:firestarter"))
	local fuel_deadline = deadline()
	for _, mode in ipairs({"protected", "claim", "distance"}) do
		deny(mode)
		eq(use("hearth:copper_charge"):get_count(), 1)
		eq(api.get_meta(hearth_pos):get_string("job_kind"), "")
		eq(deadline(), fuel_deadline)
	end
	protected, claimed, distant = false, true, false
	use("hearth:copper_charge"); advance(45)
	for _, mode in ipairs({"protected", "claim", "distance"}) do
		deny(mode); use("")
		eq(#inventory.added, 0)
		eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:copper_ingot")
	end
	protected, claimed, distant = false, true, false
	use("")
	eq(#inventory.added, 1)
end)

test("raw minerals planks and unknown species cannot act as fuel or charges", function()
	use("hearth:coal"); starter(stack("hearth:firestarter"))
	local fuel_deadline = deadline()
	for _, item in ipairs({"copper_ore", "quartz", "copper_ingot", "oak_planks", "beech_planks", "aspen_planks",
		"rowan_planks", "hazel_planks", "spruce_planks", "wall", "frame", "roof", "door", "storage",
		"deadwood", "spruce_mature", "beech_leaves", "granite_bricks", "unknown_log", "group:tree"}) do
		eq(use("hearth:" .. item):get_count(), 1)
		eq(api.get_meta(hearth_pos):get_string("job_kind"), "")
		eq(deadline(), fuel_deadline)
	end
end)

test("copper result cannot validate a forged iron job or invalid cost", function()
	local meta = api.get_meta(hearth_pos)
	for _, kind in ipairs({"smelt", "smelt_copper"}) do
		meta:set_string("job_kind", kind)
		meta:set_string("job_until", tostring(now - 1))
		meta:set_int("job_cost", kind == "smelt" and 30 or 29)
		meta:set_string("job_result", "hearth:copper_ingot")
		processes.fire_tick(hearth_pos); use("")
		eq(meta:get_string("job_result"), "")
		eq(#inventory.added, 0)
	end
end)

test("drying charges preserve food with bounded offline completion", function()
	for _ = 1, 4 do use("hearth:charcoal") end
	starter(stack("hearth:firestarter"))
	local charge = use("hearth:dried_food_charge")
	eq(charge:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "dry")
	game_now, now = game_now + 300, now + 300 -- Simulate absence; LBM/timer reconciliation catches up once.
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:dried_food")
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:dried_food")
	use("")
	eq(inventory.added[1], "hearth:dried_food")
end)

test("pottery fires once and preserves its output across repeated reconciliation", function()
	use("hearth:charcoal")
	use("hearth:charcoal")
	starter(stack("hearth:firestarter"))
	local charge = use("hearth:clay_jar_charge")
	eq(charge:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "fire")
	eq(deadline(), now + 150)
	game_now, now = game_now + 120, now + 120
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:clay_jar")
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:clay_jar")
	use("")
	eq(inventory.added[1], "hearth:clay_jar")
end)

test("one crafted charcoal preserves exactly one log of hearth fuel", function()
	use("hearth:log")
	starter(stack("hearth:firestarter"))
	local charge = use("hearth:charcoal_charge")
	eq(charge:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "char")
	advance(60)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:charcoal")
	use("")
	eq(inventory.added[1], "hearth:charcoal")
	eq(deadline(), now + 90)
	use("hearth:charcoal")
	eq(deadline(), now + 180)
end)

test("raw river fish roasts once and its output is collected safely", function()
	use("hearth:charcoal")
	starter(stack("hearth:firestarter"))
	local raw = use("hearth:raw_fish")
	eq(raw:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "roast")
	advance(8)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_fish")
	use("")
	eq(inventory.added[1], "hearth:cooked_fish")
	processes.fire_tick(hearth_pos)
	eq(inventory.added[1], "hearth:cooked_fish")
end)

test("dried river fish completes offline and stays shelf-stable output", function()
	use("hearth:log")
	use("hearth:log")
	starter(stack("hearth:firestarter"))
	local charge = use("hearth:fish_drying_charge")
	eq(charge:get_count(), 0)
	eq(api.get_meta(hearth_pos):get_string("job_kind"), "dry_fish")
	game_now, now = game_now + 300, now + 300
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:dried_fish")
	processes.fire_tick(hearth_pos)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:dried_fish")
	use("")
	eq(inventory.added[1], "hearth:dried_fish")
end)

test("invalid job metadata fails closed without producing or charging output", function()
	local meta = api.get_meta(hearth_pos)
	meta:set_int("lit", 1)
	meta:set_string("fuel_until", tostring(now + 90))
	meta:set_string("job_kind", "cook")
	meta:set_int("job_until", game_now + 4)
	meta:set_int("job_cost", 999)
	meta:set_string("job_result", "hearth:cooked_food")
	processes.fire_tick(hearth_pos)
	eq(meta:get_string("job_kind"), "")
	eq(meta:get_string("job_result"), "")
	eq(deadline(), now + 90)
	processes.fire_tick(hearth_pos)
	eq(meta:get_string("job_result"), "")
	meta:set_string("job_result", "hearth:cooked_food")
	meta:set_int("job_cost", 20)
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(#inventory.added, 0)
	processes.fire_tick(hearth_pos)
	eq(meta:get_string("job_result"), "")
end)

test("protection, claim and six-block checks cover fuel, jobs, ignition and output", function()
	protected = true
	eq(use("hearth:sticks"):get_count(), 1)
	eq(starter(stack("hearth:firestarter")).wear, 0)
	eq(violations, 2)
	protected, claimed = false, false
	eq(use("hearth:sticks"):get_count(), 1)
	eq(use("hearth:raw_food"):get_count(), 1)
	claimed, distant = true, true
	eq(starter(stack("hearth:firestarter")).wear, 0)
	eq(violations, 5)
	distant = false
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:raw_food")
	advance(6)
	protected = true
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(#inventory.added, 0)
	eq(api.get_meta(hearth_pos):get_string("job_result"), "hearth:cooked_food")
end)

test("destroyed hearth callbacks cannot recreate nodes or claim vanished output", function()
	use("hearth:sticks")
	starter(stack("hearth:firestarter"))
	use("hearth:raw_food")
	advance(6)
	world[key(hearth_pos)] = {name = "air"}
	metadata[key(hearth_pos)], timers[key(hearth_pos)] = nil, nil
	local before = #inventory.added
	processes.use_fire(hearth_pos, api.get_node(hearth_pos), player, stack(""))
	eq(processes.fire_tick(hearth_pos), false)
	eq(api.get_node(hearth_pos).name, "air")
	eq(#inventory.added, before)
end)

os.time = real_time
print("1.." .. passed)