building.lua

-- building.lua
-- Converts NPC site building materials on map load:
--   hardwood logs -> earthenware bricks
--   non-ceramic stone -> concrete
--
-- DFHack tiletype reference: https://github.com/DFHack/dfhack/blob/master/library/TileTypes.cpp

local CONCRETE_TOKEN = "INORGANIC:CONCRETE"
local EARTHENWARE_TOKEN = "INORGANIC:CERAMIC_EARTHENWARE"
local STONEWARE_TOKEN = "INORGANIC:CERAMIC_STONEWARE"
local GLASS_CLEAR_TOKEN = "GLASS_CLEAR"
local IRON_TOKEN = "INORGANIC:IRON"
local HARDWOOD_LOG_TOKEN = "PLANT:HARDWOOD_TREE:WOOD"
local HARDWOOD_LOG_TOKEN_LEGACY = "PLANT_MAT:HARDWOOD_TREE:WOOD"
local PLYWOOD_LOG_TOKEN = "PLANT:PLYWOOD_TREE:WOOD"
local PLYWOOD_LOG_TOKEN_LEGACY = "PLANT_MAT:PLYWOOD_TREE:WOOD"
local HAMLET_HARDWOOD_CONVERT_PERCENT = 30
local INITIAL_FORCE_DELAY_TICKS = 100

local CONCRETE_MAT_TYPE
local CONCRETE_MAT_INDEX
local EARTHENWARE_MAT_TYPE
local EARTHENWARE_MAT_INDEX
local STONEWARE_MAT_TYPE
local STONEWARE_MAT_INDEX
local GLASS_CLEAR_MAT_TYPE
local GLASS_CLEAR_MAT_INDEX
local IRON_MAT_TYPE
local IRON_MAT_INDEX
local HARDWOOD_MAT_TYPE
local HARDWOOD_MAT_INDEX
local PLYWOOD_MAT_TYPE
local PLYWOOD_MAT_INDEX
-- Maps LRUD connection suffix → ConstructedWall<suffix> tiletype index.
-- Used to preserve connection direction when rewriting stone wall tiles.
local constructed_wall_by_suffix = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat then
            local suffix = tostring(name):match("^ConstructedWall([LRUD]*)$")
            if suffix ~= nil then
                t[suffix] = i
            end
        end
    end
    return t
end)()

-- Maps LRUD connection suffix → ConstructedFortification<suffix> tiletype index.
local constructed_fortification_by_suffix = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat then
            local suffix = tostring(name):match("^ConstructedFortification([LRUD]*)$")
            if suffix ~= nil then
                t[suffix] = i
            end
        end
    end
    return t
end)()

-- ── STONE CONSTRUCTION TILE RULES ─────────────────────────────────────────────
-- Add/remove entries here to control which worldgen stone tiles get converted.
--   pattern      : Lua pattern matched against the tiletype name
--   inside_only  : true = skip tile if designation.outside is true (natural surface)
--   target_fn    : function(name) → target tiletype index (nil = add record, skip rewrite)
-- ──────────────────────────────────────────────────────────────────────────────
local STONE_CONSTR_RULES  -- defined after constructs (moved there)

local CONSTRUCTED_RAMP_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name):find("^ConstructedRamp") then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_FLOOR_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedFloor" then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_PILLAR_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedPillar" then
            return i
        end
    end
    return nil
end)()

local CONSTRUCTED_WALL_TT = (function()
    local constr_mat = df.tiletype_material.CONSTRUCTION

    -- Prefer the canonical connected constructed wall token if present.
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name) == "ConstructedWallLRUD" then
            return i
        end
    end

    -- Fallback to any ConstructedWall* token in this raws/tileset.
    for i = 0, 65535 do
        local name = df.tiletype[i]
        local attrs = df.tiletype.attrs[i]
        if name and attrs and attrs.material == constr_mat and tostring(name):find("^ConstructedWall") then
            return i
        end
    end

    -- Final fallback: classic wall-shape construction.
    local wall_shape = df.tiletype_shape_basic.Wall
    for i = 0, 1000 do
        local attrs = df.tiletype.attrs[i]
        if attrs and attrs.shape == wall_shape and attrs.material == constr_mat then
            return i
        end
    end
    return nil
end)()

STONE_CONSTR_RULES = { -- assigned here; cache built immediately after
    { pattern = "WallSmooth",   inside_only = false, target_fn = function(name)
        local suffix = name:match("([LRUD]*)$") or ""
        return constructed_wall_by_suffix[suffix] or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Fortif",       inside_only = false, target_fn = function(name)
        local suffix = name:match("([LRUD]*)$") or ""
        return constructed_fortification_by_suffix[suffix] or constructed_fortification_by_suffix[""] or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Pillar",       inside_only = true,  target_fn = function(_)
        return CONSTRUCTED_PILLAR_TT or CONSTRUCTED_WALL_TT
    end },
    { pattern = "Ramp",         inside_only = true,  target_fn = function(_)
        return CONSTRUCTED_RAMP_TT
    end },
}

-- Precomputed per-tiletype lookup built from STONE_CONSTR_RULES.
-- Avoids all string operations in the Pass 2 hot path: one table lookup per tile.
-- Value: {target=tiletype_index_or_nil, inside_only=bool}, or nil if not a candidate.
local stone_constr_tt_cache = (function()
    local t = {}
    local constr_mat = df.tiletype_material.CONSTRUCTION
    for tt = 0, 65535 do
        local name = tostring(df.tiletype[tt] or "")
        local attrs = df.tiletype.attrs[tt]
        if attrs and attrs.material ~= constr_mat then
            local sp = name:find("^Stone") or name:find("^Lava") or
                       name:find("^Mineral") or name:find("^Feature")
            if sp then
                for _, rule in ipairs(STONE_CONSTR_RULES) do
                    if name:find(rule.pattern) then
                        t[tt] = {target = rule.target_fn(name), inside_only = rule.inside_only}
                        break
                    end
                end
            end
        end
    end
    return t
end)()

local S = rawget(_G, "__building_state")
if not S then
    S = {
        debug = false,
        last_map_key = nil,
        watcher_enabled = false,
        watcher_gen = 0,
        watcher_interval = 5,
        init_force_gen = 0,
        processed_blocks = {},  -- block keys already scanned by Pass 2
        last_site_id = nil,     -- site id when processed_blocks was last reset
        floor_scan_gen = 0,
        floor_scan_interval = 150,   -- ticks between nearby floor scans
        keep_bounds = {},            -- cached keep bounding boxes for periodic courtyard scan
    }
    _G.__building_state = S
end

local function log(msg)
    print("[building] " .. msg)
end

local function dlog(msg)
    if S.debug then
        log("DIAG: " .. msg)
    end
end

local function add_count(tbl, key)
    if not key then key = "<nil>" end
    tbl[key] = (tbl[key] or 0) + 1
end

local function log_top_counts(prefix, tbl, limit)
    local rows = {}
    for k, v in pairs(tbl) do
        rows[#rows + 1] = {k = k, v = v}
    end
    table.sort(rows, function(a, b)
        if a.v == b.v then
            return tostring(a.k) < tostring(b.k)
        end
        return a.v > b.v
    end)
    local n = math.min(limit or 10, #rows)
    if n == 0 then
        dlog(prefix .. ": none")
        return
    end
    for i = 1, n do
        dlog(("%s [%d] %s = %d"):format(prefix, i, tostring(rows[i].k), rows[i].v))
    end
end

local function hash_percent(site_id, a, b, c)
    local mod = 2147483647
    local h = 1234567
    h = (h * 1103515245 + (site_id or 0) + 12345) % mod
    h = (h * 1103515245 + (a or 0) + 12345) % mod
    h = (h * 1103515245 + (b or 0) + 12345) % mod
    h = (h * 1103515245 + (c or 0) + 12345) % mod
    return h % 100
end

local function get_current_site()
    if dfhack.world and dfhack.world.getCurrentSite then
        return dfhack.world.getCurrentSite()
    end
    if df.global.plotinfo and df.global.plotinfo.site_id and df.global.plotinfo.site_id >= 0 then
        return df.world_site.find(df.global.plotinfo.site_id)
    end
    return nil
end

local HARSH_BIOMES = {
    [df.biome_type.DESERT_BADLAND] = true,
    [df.biome_type.DESERT_ROCK]    = true,
    [df.biome_type.DESERT_SAND]    = true,
    [df.biome_type.TUNDRA]         = true,
}

local function get_map_biome_id()
    if not dfhack.isMapLoaded() then return nil end
    local wm = df.global.world.map
    local xmax, ymax = dfhack.maps.getTileSize()
    local cx = math.floor(xmax / 2)
    local cy = math.floor(ymax / 2)
    local ground_z = (wm.z_count - 2) - df.global.world.worldgen.worldgen_parms.levels_above_ground
    local rgnX, rgnY
    for z = ground_z, 0, -1 do
        rgnX, rgnY = dfhack.maps.getTileBiomeRgn(cx, cy, z)
        if rgnX then break end
    end
    if not rgnX then return nil end
    return dfhack.maps.getBiomeType(rgnX, rgnY)
end

local function get_site_policy()
    local site = get_current_site()
    local site_id = site and site.id or -1
    local site_type = site and df.world_site_type[site.type] or "NONE"
    local site_type_l = tostring(site_type):lower()
    local is_hamlet = (site_type_l:find("hamlet") ~= nil) or (site_type_l:find("hillock") ~= nil)
    local biome_id = get_map_biome_id()
    local is_harsh_biome = biome_id ~= nil and HARSH_BIOMES[biome_id] == true
    return {
        site = site,
        site_id = site_id,
        site_type = tostring(site_type),
        is_hamlet = is_hamlet,
        hardwood_percent = is_hamlet and HAMLET_HARDWOOD_CONVERT_PERCENT or 100,
        is_harsh_biome = is_harsh_biome,
    }
end

local function should_convert_hardwood_id(site_id, id_a, id_b, id_c, percent)
    if percent >= 100 then return true end
    return hash_percent(site_id, id_a, id_b, id_c) < percent
end

local function find_materials()
    local concrete = dfhack.matinfo.find(CONCRETE_TOKEN)
    if not concrete then
        log(CONCRETE_TOKEN .. " material not found in raws")
        return false
    end
    local earthenware = dfhack.matinfo.find(EARTHENWARE_TOKEN)
    if not earthenware then
        log(EARTHENWARE_TOKEN .. " material not found in raws")
        return false
    end
    local stoneware = dfhack.matinfo.find(STONEWARE_TOKEN)
    if not stoneware then
        log(STONEWARE_TOKEN .. " material not found in raws")
        return false
    end
    local hardwood = dfhack.matinfo.find(HARDWOOD_LOG_TOKEN)
        or dfhack.matinfo.find(HARDWOOD_LOG_TOKEN_LEGACY)
    if not hardwood then
        log("WARNING: hardwood material not found; natural floors will not be converted")
    end

    CONCRETE_MAT_TYPE = concrete.type
    CONCRETE_MAT_INDEX = concrete.index
    EARTHENWARE_MAT_TYPE = earthenware.type
    EARTHENWARE_MAT_INDEX = earthenware.index
    STONEWARE_MAT_TYPE = stoneware.type
    STONEWARE_MAT_INDEX = stoneware.index
    if hardwood then
        HARDWOOD_MAT_TYPE = hardwood.type
        HARDWOOD_MAT_INDEX = hardwood.index
    end

    local glass = dfhack.matinfo.find(GLASS_CLEAR_TOKEN)
    if not glass then
        log("WARNING: " .. GLASS_CLEAR_TOKEN .. " not found; glass block walls will not be placed")
    else
        GLASS_CLEAR_MAT_TYPE = glass.type
        GLASS_CLEAR_MAT_INDEX = glass.index
    end

    local iron = dfhack.matinfo.find(IRON_TOKEN)
    if not iron then
        log("WARNING: " .. IRON_TOKEN .. " not found; iron fortifications will not be placed")
    else
        IRON_MAT_TYPE = iron.type
        IRON_MAT_INDEX = iron.index
    end

    local plywood = dfhack.matinfo.find(PLYWOOD_LOG_TOKEN)
        or dfhack.matinfo.find(PLYWOOD_LOG_TOKEN_LEGACY)
    if not plywood then
        log("WARNING: plywood material not found; plywood buildings will not receive windows")
    else
        PLYWOOD_MAT_TYPE = plywood.type
        PLYWOOD_MAT_INDEX = plywood.index
    end

    return true
end

local function map_key()
    if not dfhack.isMapLoaded() then return nil end
    local wm = df.global.world.map
    local cons = df.global.world.event.constructions
    return ("%d,%d,%d,%d,%d,%d"):format(
        wm.region_x, wm.region_y, wm.x_count, wm.y_count, #wm.map_blocks, #cons)
end

local function block_key(x, y, z)
    local bx = x - (x % 16)
    local by = y - (y % 16)
    return ("%d,%d,%d"):format(bx, by, z)
end

local function get_block_and_local(block_cache, x, y, z)
    local bk = block_key(x, y, z)
    local block = block_cache[bk]
    if block == nil then
        block = dfhack.maps.getTileBlock(x, y, z)
        block_cache[bk] = block or false
    elseif block == false then
        block = nil
    end
    if not block then return nil end
    return block, x % 16, y % 16
end

local function is_path_tile(tt)
    local name = df.tiletype[tt]
    return name ~= nil and name:find("Path") ~= nil
end

local function is_natural_floor_or_ramp(tt)
    local attrs = df.tiletype.attrs[tt]
    if not attrs then return false end
    return attrs.shape == df.tiletype_shape_basic.Floor or attrs.shape == df.tiletype_shape_basic.Ramp
end

local function likely_worldgen_road_construction(c, block_cache)
    local block, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
    if not block then return false end

    if not block.designation[lx][ly].outside then
        return false
    end

    local tt = block.tiletype[lx][ly]
    -- Building conversion should only exclude true path road tiles.
    return is_path_tile(tt)
end

local function decode_token(mat_type, mat_index)
    local info = dfhack.matinfo.decode(mat_type, mat_index)
    if not info then return nil, nil end
    return info:getToken(), info
end

local function is_stone_for_concrete(info)
    if not info or not info.material or not info.material.flags then
        return false
    end
    local f = info.material.flags
    return f.IS_STONE and not f.IS_CERAMIC
end

local function is_builtin_inorganic(token, info)
    return info and info.mode == "builtin" and token == "INORGANIC"
end

local function key_xyz(x, y, z)
    return ("%d,%d,%d"):format(x, y, z)
end

local function is_building_tile(block, lx, ly)
    return block.occupancy[lx][ly].building ~= 0
end

local function set_construction_material(c, mat_type, mat_index)
    if c.mat_type == mat_type and c.mat_index == mat_index then
        return false
    end
    c.mat_type = mat_type
    c.mat_index = mat_index
    return true
end

local function diag_walls(radius)
    if not dfhack.isMapLoaded() then
        log("No map loaded.")
        return
    end
    local adv = dfhack.world.getAdventurer()
    if not adv or not adv.pos then
        log("No active adventurer found for diag scan.")
        return
    end
    local r = tonumber(radius) or 20
    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local constructions = df.global.world.event.constructions
    local existing = {}
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
    end

    local walls_seen = 0
    local walls_with_construction = 0
    local by_name = {}
    local by_name_with_construction = {}

    for y = cy - r, cy + r do
        for x = cx - r, cx + r do
            local block = dfhack.maps.getTileBlock(x, y, cz)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local attrs = df.tiletype.attrs[tt]
                if attrs and (attrs.shape == df.tiletype_shape_basic.Wall or attrs.shape == df.tiletype_shape_basic.Fortification) then
                    walls_seen = walls_seen + 1
                    local name = tostring(df.tiletype[tt] or ("tt_" .. tostring(tt)))
                    add_count(by_name, name)
                    if existing[key_xyz(x, y, cz)] then
                        walls_with_construction = walls_with_construction + 1
                        add_count(by_name_with_construction, name)
                    end
                end
            end
        end
    end

    log(("Diag walls around adventurer r=%d: walls_seen=%d walls_with_construction=%d"):format(
        r, walls_seen, walls_with_construction))
    if S.debug then
        log_top_counts("diag wall tiletype", by_name, 20)
        log_top_counts("diag wall tiletype with construction", by_name_with_construction, 20)
    end
end

local KEEP_COURTYARD_EXPAND = 10 -- tiles to expand keep bounds beyond the TowerTop bounding box
local KEEP_Z_RANGE          = 4  -- z-levels above and below seed z to scan for outdoor ground tiles

-- Materials treated as paveable natural ground around keeps:
-- grass (all variants), soil/dirt, bare stone, lava stone, mineral stone.
local KEEP_PAVE_MATS = (function()
    local t = {}
    for _, name in ipairs({
        "GRASS", "GRASS_LIGHT", "GRASS_DARK", "GRASS_DRY", "GRASS_DEAD",
        "SOIL", "STONE", "LAVA_STONE", "MINERAL",
    }) do
        local ok, v = pcall(function() return df.tiletype_material[name] end)
        if ok and v ~= nil then t[v] = true end
    end
    return t
end)()

local function convert_map_constructions(policy, force)
    local wm = df.global.world.map

    local constructions = df.global.world.event.constructions
    local block_cache = {}
    local road_cache = {}
    local mat_cache = {}

    local changed_hardwood = 0
    local skipped_hardwood = 0
    local changed_stone = 0
    local already_target = 0
    local skipped_roads = 0
    local considered = 0
    local token_counts = {}
    local mode_counts = {}
    local unresolved_counts = {}
    local matpair_counts = {}
    local hardwood_keys = {}
    local existing = {}
    local fallback_wall_changed = 0
    local fallback_wall_inserted = 0
    local fallback_wall_candidates = 0
    local natural_floor_inserted = 0
    local glass_walls_placed = 0
    local iron_fortifications_placed = 0
    local mud_paved = 0

    local function get_matinfo(mat_type, mat_index)
        local mk = ("%d:%d"):format(mat_type, mat_index)
        local cached = mat_cache[mk]
        if cached ~= nil then
            if cached == false then return nil, nil end
            return cached.token, cached.info
        end
        local token, info = decode_token(mat_type, mat_index)
        if not token or not info then
            mat_cache[mk] = false
            return nil, nil
        end
        mat_cache[mk] = {token = token, info = info}
        return token, info
    end

    local function is_road(c)
        local k = key_xyz(c.pos.x, c.pos.y, c.pos.z)
        local v = road_cache[k]
        if v ~= nil then return v end
        v = likely_worldgen_road_construction(c, block_cache)
        road_cache[k] = v
        return v
    end

    local function is_loaded_construction(c)
        return dfhack.maps.getTileBlock(c.pos) ~= nil
    end

    -- Build connected hardwood groups so hamlet policy applies per-house, not per-tile.
    if policy.is_hamlet then
        local hardwood_lookup = {}
        for i = 0, #constructions - 1 do
            local c = constructions[i]
            if is_loaded_construction(c) then
                if not is_road(c) then
                    local token = get_matinfo(c.mat_type, c.mat_index)
                    if token == HARDWOOD_LOG_TOKEN or token == HARDWOOD_LOG_TOKEN_LEGACY then
                        local k = key_xyz(c.pos.x, c.pos.y, c.pos.z)
                        hardwood_lookup[k] = c
                    end
                end
            end
        end

        local seen = {}
        for root_k, root_c in pairs(hardwood_lookup) do
            if not seen[root_k] then
                local stack = {root_c}
                local component = {}
                seen[root_k] = true
                while #stack > 0 do
                    local cur = stack[#stack]
                    stack[#stack] = nil
                    local ck = key_xyz(cur.pos.x, cur.pos.y, cur.pos.z)
                    component[#component + 1] = cur
                    local nbrs = {
                        {cur.pos.x + 1, cur.pos.y, cur.pos.z},
                        {cur.pos.x - 1, cur.pos.y, cur.pos.z},
                        {cur.pos.x, cur.pos.y + 1, cur.pos.z},
                        {cur.pos.x, cur.pos.y - 1, cur.pos.z},
                        {cur.pos.x, cur.pos.y, cur.pos.z + 1},
                        {cur.pos.x, cur.pos.y, cur.pos.z - 1},
                    }
                    for _, n in ipairs(nbrs) do
                        local nk = key_xyz(n[1], n[2], n[3])
                        local nc = hardwood_lookup[nk]
                        if nc and not seen[nk] then
                            seen[nk] = true
                            stack[#stack + 1] = nc
                        end
                    end
                end

                local rep = component[1]
                local do_convert = should_convert_hardwood_id(
                    policy.site_id, rep.pos.x, rep.pos.y, rep.pos.z, policy.hardwood_percent)
                for _, cc in ipairs(component) do
                    hardwood_keys[key_xyz(cc.pos.x, cc.pos.y, cc.pos.z)] = do_convert
                end
            end
        end
    end

    -- Single pass: classify + convert non-road constructions.
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
        if is_loaded_construction(c) then
            if is_road(c) then
                skipped_roads = skipped_roads + 1
            else
                considered = considered + 1
                local token, info = get_matinfo(c.mat_type, c.mat_index)
                if token then
                    add_count(token_counts, token)
                else
                    add_count(unresolved_counts, ("%d:%d"):format(c.mat_type, c.mat_index))
                end
                add_count(matpair_counts, ("%d:%d"):format(c.mat_type, c.mat_index))
                if info then
                    add_count(mode_counts, info.mode or "<nil>")
                else
                    add_count(mode_counts, "<unresolved>")
                end
                if token == HARDWOOD_LOG_TOKEN or token == HARDWOOD_LOG_TOKEN_LEGACY then
                    local allow = true
                    if policy.is_hamlet then
                        local hk = key_xyz(c.pos.x, c.pos.y, c.pos.z)
                        allow = hardwood_keys[hk] == true
                    end
                    if allow then
                        -- Classify by tile shape: floor→stoneware/hardwood, else→earthenware wall.
                        local block2, lx2, ly2 = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                        local shape2 = nil
                        if block2 then
                            local attrs2 = df.tiletype.attrs[block2.tiletype[lx2][ly2]]
                            if attrs2 then shape2 = attrs2.shape end
                        end
                        if shape2 == df.tiletype_shape_basic.Floor then
                            -- Check tile above: open sky above = roof, solid/walled above = interior floor.
                            local is_roof = false
                            local block_a, lx_a, ly_a = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z + 1)
                            if block_a then
                                local tt_a = block_a.tiletype[lx_a][ly_a]
                                local attrs_a = df.tiletype.attrs[tt_a]
                                if attrs_a and attrs_a.shape == df.tiletype_shape_basic.Open
                                    and block_a.designation[lx_a][ly_a].outside then
                                    is_roof = true
                                end
                            else
                                -- No block loaded above: assume open sky (roof).
                                is_roof = true
                            end
                            if is_roof then
                                -- Roof → stoneware tile.
                                if set_construction_material(c, STONEWARE_MAT_TYPE, STONEWARE_MAT_INDEX) then
                                    c.item_type = df.item_type.BLOCKS
                                    changed_hardwood = changed_hardwood + 1
                                else
                                    already_target = already_target + 1
                                end
                            else
                                -- Ground floor → keep hardwood material, fix item_type.
                                if c.item_type ~= df.item_type.BLOCKS then
                                    c.item_type = df.item_type.BLOCKS
                                    changed_hardwood = changed_hardwood + 1
                                else
                                    already_target = already_target + 1
                                end
                            end
                        else
                            -- Wall, ramp, stair, etc. → earthenware (concrete in desert/tundra biomes).
                            local wall_mat_type  = policy.is_harsh_biome and CONCRETE_MAT_TYPE  or EARTHENWARE_MAT_TYPE
                            local wall_mat_index = policy.is_harsh_biome and CONCRETE_MAT_INDEX or EARTHENWARE_MAT_INDEX
                            if set_construction_material(c, wall_mat_type, wall_mat_index) then
                                c.item_type = df.item_type.BLOCKS
                                changed_hardwood = changed_hardwood + 1
                            else
                                already_target = already_target + 1
                            end
                        end
                    else
                        skipped_hardwood = skipped_hardwood + 1
                    end
                elseif token == PLYWOOD_LOG_TOKEN or token == PLYWOOD_LOG_TOKEN_LEGACY then
                    -- Plywood buildings: same shape-based logic as hardwood.
                    -- Roof floor → stoneware, interior floor → keep plywood, walls → earthenware.
                    local block2, lx2, ly2 = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                    local shape2 = nil
                    if block2 then
                        local attrs2 = df.tiletype.attrs[block2.tiletype[lx2][ly2]]
                        if attrs2 then shape2 = attrs2.shape end
                    end
                    if shape2 == df.tiletype_shape_basic.Floor then
                        local is_roof = false
                        local block_a, lx_a, ly_a = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z + 1)
                        if block_a then
                            local tt_a = block_a.tiletype[lx_a][ly_a]
                            local attrs_a = df.tiletype.attrs[tt_a]
                            if attrs_a and attrs_a.shape == df.tiletype_shape_basic.Open
                                and block_a.designation[lx_a][ly_a].outside then
                                is_roof = true
                            end
                        else
                            is_roof = true
                        end
                        if is_roof then
                            -- Roof → stoneware tile.
                            if set_construction_material(c, STONEWARE_MAT_TYPE, STONEWARE_MAT_INDEX) then
                                c.item_type = df.item_type.BLOCKS
                                changed_hardwood = changed_hardwood + 1
                            else
                                already_target = already_target + 1
                            end
                        else
                            -- Interior floor → keep plywood, fix item_type.
                            if c.item_type ~= df.item_type.BLOCKS then
                                c.item_type = df.item_type.BLOCKS
                                changed_hardwood = changed_hardwood + 1
                            else
                                already_target = already_target + 1
                            end
                        end
                    else
                        -- Wall, ramp, stair, etc. → earthenware (concrete in desert/tundra biomes).
                        local wall_mat_type  = policy.is_harsh_biome and CONCRETE_MAT_TYPE  or EARTHENWARE_MAT_TYPE
                        local wall_mat_index = policy.is_harsh_biome and CONCRETE_MAT_INDEX or EARTHENWARE_MAT_INDEX
                        if set_construction_material(c, wall_mat_type, wall_mat_index) then
                            c.item_type = df.item_type.BLOCKS
                            changed_hardwood = changed_hardwood + 1
                        else
                            already_target = already_target + 1
                        end
                    end
                elseif is_stone_for_concrete(info) or is_builtin_inorganic(token, info)
                    or c.item_type == df.item_type.BOULDER then
                    if set_construction_material(c, CONCRETE_MAT_TYPE, CONCRETE_MAT_INDEX) then
                        changed_stone = changed_stone + 1
                    else
                        already_target = already_target + 1
                    end
                elseif not token then
                    -- unresolvable material: if the tile is a construction-type wall, assume stone → concrete
                    local block2, lx2, ly2 = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                    if block2 then
                        local tt2 = block2.tiletype[lx2][ly2]
                        local attrs2 = df.tiletype.attrs[tt2]
                        if attrs2 and attrs2.material == df.tiletype_material.CONSTRUCTION then
                            local shape2 = attrs2.shape
                            if shape2 == df.tiletype_shape_basic.Wall or shape2 == df.tiletype_shape_basic.Fortification then
                                if set_construction_material(c, CONCRETE_MAT_TYPE, CONCRETE_MAT_INDEX) then
                                    changed_stone = changed_stone + 1
                                else
                                    already_target = already_target + 1
                                end
                            end
                        end
                    end
                end
            end
        end
    end

    -- Pass 2: natural stone wall tiles without construction records.
    -- Uses stone_constr_tt_cache (precomputed from STONE_CONSTR_RULES) for O(1) per-tile lookup.

    -- Reset block cache on site change or explicit force.
    if force or policy.site_id ~= S.last_site_id then
        S.processed_blocks = {}
        S.last_site_id = policy.site_id
    end

    for _, block in ipairs(wm.map_blocks) do
        local bk = ("%d,%d,%d"):format(block.map_pos.x, block.map_pos.y, block.map_pos.z)
        if not S.processed_blocks[bk] then
        S.processed_blocks[bk] = true
        for lx = 0, 15 do
            for ly = 0, 15 do
                local tt = block.tiletype[lx][ly]
                local cached = stone_constr_tt_cache[tt]
                local target_tt = false
                if cached and (not cached.inside_only or not block.designation[lx][ly].outside) then
                    target_tt = cached.target  -- nil = record only, number = rewrite tiletype
                end
                if target_tt ~= false then
                    local x = block.map_pos.x + lx
                    local y = block.map_pos.y + ly
                    local z = block.map_pos.z
                    fallback_wall_candidates = fallback_wall_candidates + 1
                    local k = key_xyz(x, y, z)
                    if not existing[k] then
                        local c2 = df.construction:new()
                        c2.pos.x = x; c2.pos.y = y; c2.pos.z = z
                        c2.mat_type = CONCRETE_MAT_TYPE
                        c2.mat_index = CONCRETE_MAT_INDEX
                        c2.original_tile = tt
                        if dfhack.constructions.insert(c2) then
                            fallback_wall_inserted = fallback_wall_inserted + 1
                            existing[k] = c2
                        end
                        if target_tt then
                            block.tiletype[lx][ly] = target_tt
                        end
                    elseif target_tt then
                        -- Record exists but tiletype not yet rewritten.
                        block.tiletype[lx][ly] = target_tt
                    end
                elseif HARDWOOD_MAT_TYPE then
                    -- Natural floor tiles inside surface buildings → hardwood wood floor.
                    local attrs_f = df.tiletype.attrs[tt]
                    if attrs_f and attrs_f.shape == df.tiletype_shape_basic.Floor then
                        local mat_f = attrs_f.material
                        if mat_f ~= df.tiletype_material.CONSTRUCTION
                            and mat_f ~= df.tiletype_material.GRASS
                            and mat_f ~= df.tiletype_material.PLANT then
                            local desig_f = block.designation[lx][ly]
                            if not desig_f.outside and not desig_f.subterranean then
                                local x_f = block.map_pos.x + lx
                                local y_f = block.map_pos.y + ly
                                local z_f = block.map_pos.z
                                local k_f = key_xyz(x_f, y_f, z_f)
                                if not existing[k_f] then
                                    local cf = df.construction:new()
                                    cf.pos.x = x_f; cf.pos.y = y_f; cf.pos.z = z_f
                                    cf.mat_type = HARDWOOD_MAT_TYPE
                                    cf.mat_index = HARDWOOD_MAT_INDEX
                                    cf.original_tile = tt
                                    cf.item_type = df.item_type.BLOCKS
                                    if dfhack.constructions.insert(cf) then
                                        natural_floor_inserted = natural_floor_inserted + 1
                                        existing[k_f] = cf
                                        if CONSTRUCTED_FLOOR_TT then
                                            block.tiletype[lx][ly] = CONSTRUCTED_FLOOR_TT
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
        end -- if not S.processed_blocks[bk]
    end

    -- Pass 3: Glass fortifications in earthenware buildings; iron fortifications in concrete buildings.
    -- Runs every map_key change. Already-processed components are detected by adjacency to
    -- existing glass/iron-fortification tiles, so they are skipped without a separate cache.

    local function is_wall_name(name)
        return name:find("Wall") ~= nil or name:find("Fortif") ~= nil or name:find("Pillar") ~= nil
    end

    local function is_perimeter_wall(x, y, z)
        for _, d in ipairs({{1,0},{-1,0},{0,1},{0,-1}}) do
            local nb, nlx, nly = get_block_and_local(block_cache, x+d[1], y+d[2], z)
            if not nb then return true end
            local tt_name = tostring(df.tiletype[nb.tiletype[nlx][nly]] or "")
            if not is_wall_name(tt_name) then return true end
        end
        return false
    end

    local function build_wall_components(mat_type, mat_index)
        local wall_pos = {}
        for k, c in pairs(existing) do
            if c.mat_type == mat_type and c.mat_index == mat_index then
                local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
                if b then
                    local tt_name = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
                    if tt_name:find("^ConstructedWall") then
                        wall_pos[k] = c
                    end
                end
            end
        end
        local comps, visited = {}, {}
        for k, c in pairs(wall_pos) do
            if not visited[k] then
                local comp, stack = {}, {c}
                visited[k] = true
                while #stack > 0 do
                    local cur = stack[#stack]; stack[#stack] = nil
                    comp[#comp+1] = cur
                    for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}}) do
                        local nk = key_xyz(cur.pos.x+d[1], cur.pos.y+d[2], cur.pos.z+d[3])
                        if wall_pos[nk] and not visited[nk] then
                            visited[nk] = true
                            stack[#stack+1] = wall_pos[nk]
                        end
                    end
                end
                comps[#comps+1] = comp
            end
        end
        return comps
    end

    -- Returns true if any tile in comp has a 6-directional neighbor in key_set.
    local function comp_has_neighbor_in(comp, key_set)
        for _, c in ipairs(comp) do
            for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0},{0,0,1},{0,0,-1}}) do
                if key_set[key_xyz(c.pos.x+d[1], c.pos.y+d[2], c.pos.z+d[3])] then
                    return true
                end
            end
        end
        return false
    end

    local function is_door_construction(c)
        if c.item_type == df.item_type.DOOR then
            return true
        end
        local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
        if not b then return false end
        local tn = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
        return tn:find("Door") ~= nil
    end

    -- Bridges are typically outside and doorless; require at least one
    -- building-like signal before placing iron fortifications.
    local function comp_looks_like_building(comp)
        for _, c in ipairs(comp) do
            for _, d in ipairs({{1,0,0},{-1,0,0},{0,1,0},{0,-1,0}}) do
                local nx, ny, nz = c.pos.x + d[1], c.pos.y + d[2], c.pos.z + d[3]
                local b, lx, ly = get_block_and_local(block_cache, nx, ny, nz)
                if b and not b.designation[lx][ly].outside then
                    return true
                end
                local nadj = dfhack.buildings.findAtTile(nx, ny, nz)
                if nadj and nadj:getType() == df.building_type.Door then
                    return true
                end
            end
        end
        return false
    end

    -- Some bridge constructions are represented with tile names containing
    -- "bridge". Skip these in the iron-fortification window pass.
    local function comp_is_bridge_named(comp)
        for _, c in ipairs(comp) do
            local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
            if b then
                local tn = tostring(df.tiletype[b.tiletype[lx][ly]] or ""):lower()
                if tn:find("bridge") then
                    return true
                end
            end
        end
        return false
    end

    -- ── PASS 3: GEOMETRY-BASED WINDOW PLACEMENT ────────────────────────────────

    -- True if wall at (x,y,z) faces at least one outside-designated non-wall tile.
    local function is_outer_wall(x, y, z)
        for _, d in ipairs({{1,0},{-1,0},{0,1},{0,-1}}) do
            local nb, nlx, nly = get_block_and_local(block_cache, x+d[1], y+d[2], z)
            if not nb then return true end
            if not is_wall_name(tostring(df.tiletype[nb.tiletype[nlx][nly]] or "")) then
                if nb.designation[nlx][nly].outside then return true end
            end
        end
        return false
    end

    -- True if tile below (x,y,z) is not Open (i.e. at ground level).
    local function is_ground_tile(x, y, z)
        local bb, lxb, lyb = get_block_and_local(block_cache, x, y, z - 1)
        if bb then
            local ab = df.tiletype.attrs[bb.tiletype[lxb][lyb]]
            if ab and ab.shape == df.tiletype_shape_basic.Open then return false end
        end
        return true
    end

    -- Rewrite a wall tile to a fortification, preserving its LRUD connection suffix.
    local function rewrite_to_fortif(b, lx, ly)
        if not b then return end
        local cur = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
        local suffix = cur:match("ConstructedWall([LRUD]*)$") or ""
        b.tiletype[lx][ly] = constructed_fortification_by_suffix[suffix]
            or constructed_fortification_by_suffix[""]
            or CONSTRUCTED_WALL_TT
    end

    -- Site gate: windows only on hamlet/hillock/town sites.
    local site_type_l = policy.site_type:lower()
    local site_allows_windows = site_type_l:find("hamlet") ~= nil
        or site_type_l:find("hillock") ~= nil
        or site_type_l:find("town") ~= nil

    if site_allows_windows then

    -- Abstract building type inventory (all types, used for exclusion check).
    local weighted_types = {}
    do
        local site = policy.site
        if site and site.buildings then
            for i = 0, #site.buildings - 1 do
                local bld = site.buildings[i]
                local ok, bt = pcall(function()
                    return tostring(df.abstract_building_type[bld:getType()])
                end)
                if ok and bt then
                    weighted_types[#weighted_types + 1] = bt
                end
            end
        end
    end

    -- Classify a component via hash-based assignment.
    -- Returns type string, or nil for generic (house / no abstract buildings).
    local function classify_comp(comp)
        if #weighted_types == 0 then return nil end
        local rep = comp[1]
        local h = hash_percent(policy.site_id, rep.pos.x, rep.pos.y, rep.pos.z)
                + rep.pos.x * 7 + rep.pos.y * 13
        local idx = (h % #weighted_types) + 1
        return weighted_types[idx]
    end

    -- Building types that never receive windows.
    local ABL_NO_WINDOW = {TEMPLE=true, DARK_TOWER=true, UNDERWORLD_SPIRE=true,
                           TOMB=true, DUNGEON=true}

    -- True if the wall tile is straight (single axis only) based on tiletype suffix.
    local function is_straight_wall(b, lx, ly)
        local name = tostring(df.tiletype[b.tiletype[lx][ly]] or "")
        local suffix = name:match("ConstructedWall([LRUD]*)$")
        if not suffix or suffix == "" then return false end
        local has_h = suffix:find("[LR]") ~= nil
        local has_v = suffix:find("[UD]") ~= nil
        return has_h ~= has_v  -- XOR: exactly one axis
    end

    -- Window key set: pre-populated with ALL existing fortification tiles so that
    -- repeat calls never place a window adjacent to one from a previous call.
    -- (Fortification tiles are excluded from build_wall_components, so without
    -- this the algorithm "sees" walls split at prior windows and places new ones
    -- immediately adjacent to them.)
    local window_keys = {}
    for k, c in pairs(existing) do
        local b, lx, ly = get_block_and_local(block_cache, c.pos.x, c.pos.y, c.pos.z)
        if b and tostring(df.tiletype[b.tiletype[lx][ly]] or ""):find("^ConstructedFortif") then
            window_keys[k] = true
        end
    end

    -- Pre-build component lists.
    local concrete_comps    = build_wall_components(CONCRETE_MAT_TYPE,    CONCRETE_MAT_INDEX)
    local earthenware_comps = build_wall_components(EARTHENWARE_MAT_TYPE, EARTHENWARE_MAT_INDEX)
    local plywood_comps     = PLYWOOD_MAT_TYPE
        and build_wall_components(PLYWOOD_MAT_TYPE, PLYWOOD_MAT_INDEX) or {}

    for _, comp_list in ipairs({concrete_comps, earthenware_comps, plywood_comps}) do
    for _, comp in ipairs(comp_list) do
        if not comp_is_bridge_named(comp) then
            local comp_type = classify_comp(comp)
            if not ABL_NO_WINDOW[comp_type] then
                -- Door discovery: find all doors adjacent to ground-level comp tiles.
                local door_positions = {}
                local seen_doors = {}
                local comp_tile_set = {}
                for _, c in ipairs(comp) do
                    comp_tile_set[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
                end
                for _, c in ipairs(comp) do
                    if is_ground_tile(c.pos.x, c.pos.y, c.pos.z) then
                        for _, d in ipairs({{1,0},{-1,0},{0,1},{0,-1}}) do
                            local nx, ny = c.pos.x + d[1], c.pos.y + d[2]
                            local dk = key_xyz(nx, ny, c.pos.z)
                            if not seen_doors[dk] then
                                local door = dfhack.buildings.findAtTile(nx, ny, c.pos.z)
                                if door and door:getType() == df.building_type.Door then
                                    seen_doors[dk] = true
                                    door_positions[#door_positions + 1] = {x=nx, y=ny, z=c.pos.z}
                                end
                            end
                        end
                    end
                end
                -- Qualification: must have at least one door.
                if #door_positions > 0 then
                    -- Run tracing and window placement per door.
                    for _, dp in ipairs(door_positions) do
                        local ddx, ddy, ddz = dp.x, dp.y, dp.z
                        -- Detect which axes have comp tiles on either side of the door.
                        local trace_horiz = comp_tile_set[key_xyz(ddx-1, ddy, ddz)] ~= nil
                                         or comp_tile_set[key_xyz(ddx+1, ddy, ddz)] ~= nil
                        local trace_vert  = comp_tile_set[key_xyz(ddx, ddy-1, ddz)] ~= nil
                                         or comp_tile_set[key_xyz(ddx, ddy+1, ddz)] ~= nil
                        -- Split each applicable axis into two sides (closest-first).
                        -- At most one window is placed per side.
                        local sides = {}
                        if trace_horiz then
                            -- Horizontal run at y = ddy: left (x < ddx) and right (x > ddx).
                            local left, right = {}, {}
                            for _, c in ipairs(comp) do
                                if c.pos.y == ddy and c.pos.z == ddz then
                                    if c.pos.x < ddx then
                                        left[#left + 1] = c
                                    elseif c.pos.x > ddx then
                                        right[#right + 1] = c
                                    end
                                end
                            end
                            table.sort(left,  function(a,b) return a.pos.x > b.pos.x end)
                            table.sort(right, function(a,b) return a.pos.x < b.pos.x end)
                            sides[#sides + 1] = left
                            sides[#sides + 1] = right
                        end
                        if trace_vert then
                            -- Vertical run at x = ddx: top (y < ddy) and bottom (y > ddy).
                            local top, bot = {}, {}
                            for _, c in ipairs(comp) do
                                if c.pos.x == ddx and c.pos.z == ddz then
                                    if c.pos.y < ddy then
                                        top[#top + 1] = c
                                    elseif c.pos.y > ddy then
                                        bot[#bot + 1] = c
                                    end
                                end
                            end
                            table.sort(top, function(a,b) return a.pos.y > b.pos.y end)
                            table.sort(bot, function(a,b) return a.pos.y < b.pos.y end)
                            sides[#sides + 1] = top
                            sides[#sides + 1] = bot
                        end
                        -- Window placement: first eligible tile per side.
                        for _, side in ipairs(sides) do
                            for _, c in ipairs(side) do
                                local cx, cy, cz = c.pos.x, c.pos.y, c.pos.z
                                local mdist = math.abs(cx - ddx) + math.abs(cy - ddy)
                                -- Rule 1: not door-adjacent (Manhattan distance > 1).
                                if mdist > 1 and is_outer_wall(cx, cy, cz) then
                                    local b, lx, ly = get_block_and_local(block_cache, cx, cy, cz)
                                    -- Rule 3: straight wall tile (single axis only).
                                    if b and is_straight_wall(b, lx, ly) then
                                        -- Rule 4: not adjacent to another window.
                                        local adj_window = false
                                        for _, nd in ipairs({{1,0},{-1,0},{0,1},{0,-1}}) do
                                            if window_keys[key_xyz(cx+nd[1], cy+nd[2], cz)] then
                                                adj_window = true; break
                                            end
                                        end
                                        if not adj_window then
                                            local wk = key_xyz(cx, cy, cz)
                                            local placed = false
                                            -- Material: concrete → iron, others → glass.
                                            if c.mat_type == CONCRETE_MAT_TYPE
                                                and c.mat_index == CONCRETE_MAT_INDEX then
                                                if IRON_MAT_TYPE then
                                                    c.mat_type  = IRON_MAT_TYPE
                                                    c.mat_index = IRON_MAT_INDEX
                                                    window_keys[wk] = true
                                                    rewrite_to_fortif(b, lx, ly)
                                                    iron_fortifications_placed = iron_fortifications_placed + 1
                                                    placed = true
                                                elseif GLASS_CLEAR_MAT_TYPE then
                                                    c.mat_type  = GLASS_CLEAR_MAT_TYPE
                                                    c.mat_index = GLASS_CLEAR_MAT_INDEX
                                                    window_keys[wk] = true
                                                    rewrite_to_fortif(b, lx, ly)
                                                    glass_walls_placed = glass_walls_placed + 1
                                                    placed = true
                                                end
                                            else
                                                if GLASS_CLEAR_MAT_TYPE then
                                                    c.mat_type  = GLASS_CLEAR_MAT_TYPE
                                                    c.mat_index = GLASS_CLEAR_MAT_INDEX
                                                    window_keys[wk] = true
                                                    rewrite_to_fortif(b, lx, ly)
                                                    glass_walls_placed = glass_walls_placed + 1
                                                    placed = true
                                                end
                                            end
                                            if placed then break end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    end  -- for comp_list

    end  -- if site_allows_windows

    -- ── PASS 4: MUD PAVING ─────────────────────────────────────────────────────
    -- For hamlet/hillock/town sites, cover mud-spattered natural floor tiles with
    -- concrete and clear the spatter. Mud on already-constructed tiles is just cleared.
    if site_allows_windows and CONCRETE_MAT_TYPE then
        local MUD_MAT_TYPE = df.builtin_mats.MUD
        local SOLID        = df.matter_state.Solid
        for _, block in ipairs(df.global.world.map.map_blocks) do
            -- Collect mud spatter events in this block.
            local mud_events = {}
            for _, ev in ipairs(block.block_events) do
                if ev:getType() == df.block_square_event_type.material_spatter
                    and ev.mat_type == MUD_MAT_TYPE
                    and ev.mat_state == SOLID then
                    mud_events[#mud_events + 1] = ev
                end
            end
            if #mud_events == 0 then goto next_mud_block end

            for lx = 0, 15 do
                for ly = 0, 15 do
                    -- Check if this tile has mud.
                    local muddy = false
                    for _, ev in ipairs(mud_events) do
                        if ev.amount[lx][ly] > 0 then muddy = true; break end
                    end
                    if not muddy then goto next_mud_tile end

                    local wx = block.map_pos.x + lx
                    local wy = block.map_pos.y + ly
                    local wz = block.map_pos.z
                    local tt = block.tiletype[lx][ly]
                    local attrs = df.tiletype.attrs[tt]
                    -- Act on floor-shaped and ramp tiles (covers boulders, pebbles, slopes).
                    local shape_attrs = attrs and df.tiletype_shape.attrs[attrs.shape]
                    local basic = shape_attrs and shape_attrs.basic_shape
                    if basic == df.tiletype_shape_basic.Floor
                        or basic == df.tiletype_shape_basic.Ramp then
                        local k = key_xyz(wx, wy, wz)
                        if not existing[k] then
                            -- Natural floor: lay a concrete construction over it.
                            local cf = df.construction:new()
                            cf.pos.x = wx; cf.pos.y = wy; cf.pos.z = wz
                            cf.mat_type  = CONCRETE_MAT_TYPE
                            cf.mat_index = CONCRETE_MAT_INDEX
                            cf.original_tile = -1  -- prevents roads.lua from reclassifying as asphalt road
                            cf.item_type = df.item_type.BLOCKS
                            if dfhack.constructions.insert(cf) then
                                existing[k] = cf
                                local target_tt = (basic == df.tiletype_shape_basic.Ramp)
                                    and CONSTRUCTED_RAMP_TT or CONSTRUCTED_FLOOR_TT
                                if target_tt then
                                    block.tiletype[lx][ly] = target_tt
                                end
                                mud_paved = mud_paved + 1
                            end
                        end
                        -- Clear the mud spatter regardless.
                        for _, ev in ipairs(mud_events) do
                            ev.amount[lx][ly] = 0
                        end
                    end
                    ::next_mud_tile::
                end
            end
            ::next_mud_block::
        end
    end

    -- ── PASS 5: KEEP COURTYARD PAVING ──────────────────────────────────────────
    -- Locates keeps/castles via ThroneRoom/Treasury civzones, then derives the
    -- outer wall boundary from nearby TowerTop civzones, expanded by
    -- KEEP_COURTYARD_EXPAND tiles to cover the moat/apron outside the walls.
    -- Paves grass, soil, and bare stone Floor/Ramp tiles with no existing
    -- construction record.  Discovered bounds are cached in S.keep_bounds for
    -- the periodic scan_nearby_courtyards pass.
    local courtyard_paved = 0
    if CONCRETE_MAT_TYPE then
        -- Reset cache so it reflects the current map.
        S.keep_bounds = {}

        -- Collect seed zones (ThroneRoom/Treasury) and TowerTop zones.
        local seed_zones  = {}
        local tower_zones = {}
        for _, bld in ipairs(df.global.world.buildings.all) do
            if df.building_civzonest:is_instance(bld) then
                local subtype = tostring(df.civzone_type[bld:getSubtype()] or "")
                if subtype == "ThroneRoom" or subtype == "Treasury" then
                    seed_zones[#seed_zones + 1] = bld
                elseif subtype == "TowerTop" then
                    tower_zones[#tower_zones + 1] = bld
                end
            end
        end

        local KEEP_TOWER_RADIUS = 60   -- max x/y distance to associate TowerTop with a seed
        local processed_bounds = {}

        for _, seed in ipairs(seed_zones) do
            local scx = math.floor((seed.x1 + seed.x2) / 2)
            local scy = math.floor((seed.y1 + seed.y2) / 2)
            local scz = seed.z

            -- Find TowerTop zones within radius, compute bounding box, then expand.
            local bx1, by1 = math.huge,  math.huge
            local bx2, by2 = -math.huge, -math.huge
            local found = 0
            for _, tz in ipairs(tower_zones) do
                local tcx = math.floor((tz.x1 + tz.x2) / 2)
                local tcy = math.floor((tz.y1 + tz.y2) / 2)
                if math.abs(tcx - scx) <= KEEP_TOWER_RADIUS
                    and math.abs(tcy - scy) <= KEEP_TOWER_RADIUS then
                    bx1 = math.min(bx1, tz.x1)
                    by1 = math.min(by1, tz.y1)
                    bx2 = math.max(bx2, tz.x2)
                    by2 = math.max(by2, tz.y2)
                    found = found + 1
                end
            end
            if found == 0 then goto next_keep end

            -- Expand outward to cover ground just beyond the outer walls.
            bx1 = bx1 - KEEP_COURTYARD_EXPAND
            by1 = by1 - KEEP_COURTYARD_EXPAND
            bx2 = bx2 + KEEP_COURTYARD_EXPAND
            by2 = by2 + KEEP_COURTYARD_EXPAND

            -- Skip if we already processed this exact boundary (multiple seeds, same keep).
            local bounds_key = ("%d,%d,%d,%d,%d"):format(bx1, by1, bx2, by2, scz)
            if processed_bounds[bounds_key] then goto next_keep end
            processed_bounds[bounds_key] = true

            -- Cache for periodic scan (z_min/z_max define the vertical range).
            S.keep_bounds[#S.keep_bounds + 1] = {
                x1=bx1, y1=by1, x2=bx2, y2=by2,
                z=scz, z_min=scz - KEEP_Z_RANGE, z_max=scz + KEEP_Z_RANGE,
            }

            -- Scan all map blocks that overlap the bounding box across the z-range.
            -- Only pave outdoor tiles (designation.outside) to avoid touching
            -- interior rooms on adjacent z-levels.
            do
                local bbx0 = bx1 - (bx1 % 16)
                local bby0 = by1 - (by1 % 16)
                for z = scz - KEEP_Z_RANGE, scz + KEEP_Z_RANGE do
                    for bbx = bbx0, bx2, 16 do
                        for bby = bby0, by2, 16 do
                            local block = dfhack.maps.getTileBlock(bbx, bby, z)
                            if block then
                                for lx = 0, 15 do
                                    for ly = 0, 15 do
                                        local wx = bbx + lx
                                        local wy = bby + ly
                                        if wx >= bx1 and wx <= bx2
                                            and wy >= by1 and wy <= by2 then
                                            local k = key_xyz(wx, wy, z)
                                            if not existing[k]
                                                and block.designation[lx][ly].outside then
                                                local tt = block.tiletype[lx][ly]
                                                local attrs = df.tiletype.attrs[tt]
                                                if attrs and KEEP_PAVE_MATS[attrs.material] then
                                                    local shape_attrs = df.tiletype_shape.attrs[attrs.shape]
                                                    local basic = shape_attrs and shape_attrs.basic_shape
                                                    if basic == df.tiletype_shape_basic.Floor
                                                        or basic == df.tiletype_shape_basic.Ramp then
                                                        local cf = df.construction:new()
                                                        cf.pos.x = wx; cf.pos.y = wy; cf.pos.z = z
                                                        cf.mat_type  = CONCRETE_MAT_TYPE
                                                        cf.mat_index = CONCRETE_MAT_INDEX
                                                        cf.original_tile = -1
                                                        cf.item_type = df.item_type.BLOCKS
                                                        if dfhack.constructions.insert(cf) then
                                                            existing[k] = cf
                                                            local target_tt = (basic == df.tiletype_shape_basic.Ramp)
                                                                and CONSTRUCTED_RAMP_TT or CONSTRUCTED_FLOOR_TT
                                                            if target_tt then
                                                                block.tiletype[lx][ly] = target_tt
                                                            end
                                                            courtyard_paved = courtyard_paved + 1
                                                        end
                                                    end
                                                end
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
            ::next_keep::
        end
    end

    if S.debug then
        dlog(("construction material scan: considered=%d skipped_roads=%d unique_tokens=%d unique_unresolved=%d"):format(
            considered, skipped_roads, (function() local n=0 for _ in pairs(token_counts) do n=n+1 end return n end)(),
            (function() local n=0 for _ in pairs(unresolved_counts) do n=n+1 end return n end)()))
        log_top_counts("top token", token_counts, 20)
        log_top_counts("top mode", mode_counts, 10)
        log_top_counts("top mat_type:mat_index", matpair_counts, 20)
        log_top_counts("top unresolved mat_type:mat_index", unresolved_counts, 20)
    end

    return {
        considered = considered,
        skipped_roads = skipped_roads,
        changed_hardwood = changed_hardwood,
        skipped_hardwood = skipped_hardwood,
        changed_stone = changed_stone,
        fallback_wall_candidates = fallback_wall_candidates,
        fallback_wall_changed = fallback_wall_changed,
        fallback_wall_inserted = fallback_wall_inserted,
        natural_floor_inserted = natural_floor_inserted,
        glass_walls_placed = glass_walls_placed,
        iron_fortifications_placed = iron_fortifications_placed,
        mud_paved = mud_paved,
        courtyard_paved = courtyard_paved,
        already_target = already_target,
    }
end

local function convert_buildings(force, quiet)
    if not dfhack.isMapLoaded() then
        if quiet then return end
        log("No map loaded.")
        return
    end

    if not find_materials() then return end

    local this_map_key = map_key()
    if not force and S.last_map_key == this_map_key then
        if quiet then return end
        log("Already processed this map; skipping. Use 'building force' to run again.")
        return
    end

    local policy = get_site_policy()
    local map_stats = convert_map_constructions(policy, force)

    S.last_map_key = this_map_key

    dlog(("site_policy: site_id=%d site_type=%s hamlet=%s hardwood_percent=%d"):format(
        policy.site_id, policy.site_type, tostring(policy.is_hamlet), policy.hardwood_percent))
    log(("Converted map constructions (roads skipped): considered=%d skipped_roads=%d hardwood_converted=%d hardwood_kept=%d stone_to_concrete=%d wall_fallback_candidates=%d wall_fallback_changed=%d wall_fallback_inserted=%d natural_floor_inserted=%d glass_walls=%d iron_fortifications=%d mud_paved=%d courtyard_paved=%d already_target=%d policy=%s/%d%%"):format(
        map_stats.considered, map_stats.skipped_roads, map_stats.changed_hardwood, map_stats.skipped_hardwood, map_stats.changed_stone, map_stats.fallback_wall_candidates, map_stats.fallback_wall_changed, map_stats.fallback_wall_inserted, map_stats.natural_floor_inserted, map_stats.glass_walls_placed, map_stats.iron_fortifications_placed, map_stats.mud_paved, map_stats.courtyard_paved, map_stats.already_target, policy.site_type, policy.hardwood_percent))
end

local FLOOR_SCAN_RADIUS    = 48  -- tiles around player to scan each tick
local WALL_SCAN_Z_UP       = 8   -- z-levels above player to scan for walls (city walls are tall)
local WALL_SCAN_Z_DOWN     = 2   -- z-levels below player to scan for walls

local function scan_nearby_floors()
    if not HARDWOOD_MAT_TYPE then return end
    if not dfhack.isMapLoaded() then return end

    local adv = dfhack.world and dfhack.world.getAdventurer and dfhack.world.getAdventurer()
    if not adv or not adv.pos then return end

    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local r = FLOOR_SCAN_RADIUS

    -- Snap to block grid and iterate only relevant blocks
    local bx0 = cx - r - ((cx - r) % 16)
    local by0 = cy - r - ((cy - r) % 16)
    local bx1 = cx + r
    local by1 = cy + r

    local inserted = 0
    for bx = bx0, bx1, 16 do
        for by = by0, by1, 16 do
            local block = dfhack.maps.getTileBlock(bx, by, cz)
            if block then
                for lx = 0, 15 do
                    for ly = 0, 15 do
                        local tt = block.tiletype[lx][ly]
                        local attrs = df.tiletype.attrs[tt]
                        if attrs then
                            local mat = attrs.material
                            if attrs.shape == df.tiletype_shape_basic.Floor
                                and mat ~= df.tiletype_material.CONSTRUCTION
                                and mat ~= df.tiletype_material.GRASS
                                and mat ~= df.tiletype_material.PLANT then
                                local desig = block.designation[lx][ly]
                                if not desig.outside and not desig.subterranean then
                                    local wx = bx + lx
                                    local wy = by + ly
                                    local cf = df.construction:new()
                                    cf.pos.x = wx; cf.pos.y = wy; cf.pos.z = cz
                                    cf.mat_type  = HARDWOOD_MAT_TYPE
                                    cf.mat_index = HARDWOOD_MAT_INDEX
                                    cf.original_tile = tt
                                    cf.item_type = df.item_type.BLOCKS
                                    if dfhack.constructions.insert(cf) then
                                        inserted = inserted + 1
                                        if CONSTRUCTED_FLOOR_TT then
                                            block.tiletype[lx][ly] = CONSTRUCTED_FLOOR_TT
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    if inserted > 0 then
        log(("scan_nearby_floors: inserted %d hardwood floors"):format(inserted))
    end
end

-- Catch stone wall/fortification/pillar/ramp tiles that scrolled into the loaded
-- area while the player was walking (map_key doesn't change for a sliding window).
-- Mirrors Pass 2 logic but scans multiple z-levels for multi-story city walls.
local function scan_nearby_walls()
    if not CONCRETE_MAT_TYPE then return end
    if not dfhack.isMapLoaded() then return end

    local adv = dfhack.world and dfhack.world.getAdventurer and dfhack.world.getAdventurer()
    if not adv or not adv.pos then return end

    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local r = FLOOR_SCAN_RADIUS

    local bx0 = cx - r - ((cx - r) % 16)
    local by0 = cy - r - ((cy - r) % 16)
    local bx1 = cx + r
    local by1 = cy + r

    local inserted = 0
    for z = cz - WALL_SCAN_Z_DOWN, cz + WALL_SCAN_Z_UP do
        for bx = bx0, bx1, 16 do
            for by = by0, by1, 16 do
                local block = dfhack.maps.getTileBlock(bx, by, z)
                if block then
                    for lx = 0, 15 do
                        for ly = 0, 15 do
                            local tt = block.tiletype[lx][ly]
                            local cached = stone_constr_tt_cache[tt]
                            if cached and (not cached.inside_only or not block.designation[lx][ly].outside) then
                                local target_tt = cached.target
                                local c2 = df.construction:new()
                                c2.pos.x = bx + lx
                                c2.pos.y = by + ly
                                c2.pos.z = z
                                c2.mat_type    = CONCRETE_MAT_TYPE
                                c2.mat_index   = CONCRETE_MAT_INDEX
                                c2.original_tile = tt
                                if dfhack.constructions.insert(c2) then
                                    inserted = inserted + 1
                                end
                                -- Always rewrite the tiletype: the tile is still stone,
                                -- so whether insert succeeded or failed the type needs fixing.
                                if target_tt then
                                    block.tiletype[lx][ly] = target_tt
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    if inserted > 0 then
        log(("scan_nearby_walls: inserted %d concrete wall records"):format(inserted))
    end
end

-- Catch mud-spattered natural floor/ramp tiles that scroll into view during
-- normal walking.  Mirrors Pass 4: inserts a concrete construction if no record
-- exists, rewrites the tiletype, and always clears the mud spatter.
local function scan_nearby_mud()
    if not CONCRETE_MAT_TYPE then return end
    if not dfhack.isMapLoaded() then return end

    local adv = dfhack.world and dfhack.world.getAdventurer and dfhack.world.getAdventurer()
    if not adv or not adv.pos then return end

    local site = get_current_site()
    local site_type_l = site and tostring(df.world_site_type[site.type]):lower() or ""
    if not (site_type_l:find("hamlet") or site_type_l:find("hillock") or site_type_l:find("town")) then
        return
    end

    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local r = FLOOR_SCAN_RADIUS
    local MUD_MAT_TYPE = df.builtin_mats.MUD
    local SOLID        = df.matter_state.Solid

    local bx0 = cx - r - ((cx - r) % 16)
    local by0 = cy - r - ((cy - r) % 16)
    local bx1 = cx + r
    local by1 = cy + r

    local paved = 0
    for bx = bx0, bx1, 16 do
        for by = by0, by1, 16 do
            local block = dfhack.maps.getTileBlock(bx, by, cz)
            if block then
                local mud_events = {}
                for _, ev in ipairs(block.block_events) do
                    if ev:getType() == df.block_square_event_type.material_spatter
                        and ev.mat_type == MUD_MAT_TYPE
                        and ev.mat_state == SOLID then
                        mud_events[#mud_events + 1] = ev
                    end
                end
                if #mud_events > 0 then
                    for lx = 0, 15 do
                        for ly = 0, 15 do
                            local muddy = false
                            for _, ev in ipairs(mud_events) do
                                if ev.amount[lx][ly] > 0 then muddy = true; break end
                            end
                            if muddy then
                                local tt = block.tiletype[lx][ly]
                                local attrs = df.tiletype.attrs[tt]
                                local shape_attrs = attrs and df.tiletype_shape.attrs[attrs.shape]
                                local basic = shape_attrs and shape_attrs.basic_shape
                                if basic == df.tiletype_shape_basic.Floor
                                    or basic == df.tiletype_shape_basic.Ramp then
                                    local wx = bx + lx
                                    local wy = by + ly
                                    local cf = df.construction:new()
                                    cf.pos.x = wx; cf.pos.y = wy; cf.pos.z = cz
                                    cf.mat_type  = CONCRETE_MAT_TYPE
                                    cf.mat_index = CONCRETE_MAT_INDEX
                                    cf.original_tile = -1
                                    cf.item_type = df.item_type.BLOCKS
                                    if dfhack.constructions.insert(cf) then
                                        local target_tt = (basic == df.tiletype_shape_basic.Ramp)
                                            and CONSTRUCTED_RAMP_TT or CONSTRUCTED_FLOOR_TT
                                        if target_tt then
                                            block.tiletype[lx][ly] = target_tt
                                        end
                                        paved = paved + 1
                                    end
                                    -- Clear mud regardless of whether a construction was inserted.
                                    for _, ev in ipairs(mud_events) do
                                        ev.amount[lx][ly] = 0
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    end
    if paved > 0 then
        log(("scan_nearby_mud: paved %d mud-spattered tiles"):format(paved))
    end
end

-- Catch keep courtyard tiles that scroll into view while the player walks the
-- world map.  Uses bounds cached in S.keep_bounds by Pass 5; only scans
-- blocks that both overlap a keep boundary and are within FLOOR_SCAN_RADIUS
-- of the player, so the cost per tick is small.
local function scan_nearby_courtyards()
    if not CONCRETE_MAT_TYPE then return end
    if not S.keep_bounds or #S.keep_bounds == 0 then return end
    if not dfhack.isMapLoaded() then return end

    local adv = dfhack.world and dfhack.world.getAdventurer and dfhack.world.getAdventurer()
    if not adv or not adv.pos then return end

    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    local r = FLOOR_SCAN_RADIUS

    local inserted = 0
    for _, kb in ipairs(S.keep_bounds) do
        -- Skip keeps entirely out of x/y scan radius (z checked per-level below).
        if cx + r < kb.x1 or cx - r > kb.x2 then goto next_keep_scan end
        if cy + r < kb.y1 or cy - r > kb.y2 then goto next_keep_scan end

        -- Clamp x/y to the intersection of scan radius and keep bounds.
        local sx1 = math.max(kb.x1, cx - r)
        local sy1 = math.max(kb.y1, cy - r)
        local sx2 = math.min(kb.x2, cx + r)
        local sy2 = math.min(kb.y2, cy + r)

        local bbx0 = sx1 - (sx1 % 16)
        local bby0 = sy1 - (sy1 % 16)
        for z = kb.z_min, kb.z_max do
            for bbx = bbx0, sx2, 16 do
                for bby = bby0, sy2, 16 do
                    local block = dfhack.maps.getTileBlock(bbx, bby, z)
                    if block then
                        for lx = 0, 15 do
                            for ly = 0, 15 do
                                local wx = bbx + lx
                                local wy = bby + ly
                                if wx >= sx1 and wx <= sx2
                                    and wy >= sy1 and wy <= sy2
                                    and block.designation[lx][ly].outside then
                                    local tt = block.tiletype[lx][ly]
                                    local attrs = df.tiletype.attrs[tt]
                                    if attrs and KEEP_PAVE_MATS[attrs.material] then
                                        local shape_attrs = df.tiletype_shape.attrs[attrs.shape]
                                        local basic = shape_attrs and shape_attrs.basic_shape
                                        if basic == df.tiletype_shape_basic.Floor
                                            or basic == df.tiletype_shape_basic.Ramp then
                                            local cf = df.construction:new()
                                            cf.pos.x = wx; cf.pos.y = wy; cf.pos.z = z
                                            cf.mat_type  = CONCRETE_MAT_TYPE
                                            cf.mat_index = CONCRETE_MAT_INDEX
                                            cf.original_tile = -1
                                            cf.item_type = df.item_type.BLOCKS
                                            if dfhack.constructions.insert(cf) then
                                                inserted = inserted + 1
                                                local target_tt = (basic == df.tiletype_shape_basic.Ramp)
                                                    and CONSTRUCTED_RAMP_TT or CONSTRUCTED_FLOOR_TT
                                                if target_tt then
                                                    block.tiletype[lx][ly] = target_tt
                                                end
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
        ::next_keep_scan::
    end
    if inserted > 0 then
        log(("scan_nearby_courtyards: inserted %d concrete tiles"):format(inserted))
    end
end

local function floor_scan_tick(gen)
    if not S.watcher_enabled then return end
    if gen ~= S.floor_scan_gen then return end
    scan_nearby_floors()
    scan_nearby_walls()
    scan_nearby_mud()
    scan_nearby_courtyards()
    dfhack.timeout(S.floor_scan_interval, "ticks", function()
        floor_scan_tick(gen)
    end)
end

local function tick_watch(gen)
    if not S.watcher_enabled then return end
    if gen ~= S.watcher_gen then return end

    if dfhack.isMapLoaded() then
        convert_buildings(false, true)
    end

    dfhack.timeout(S.watcher_interval, "ticks", function()
        tick_watch(gen)
    end)
end

local function start_watcher()
    if S.watcher_enabled then return end
    S.watcher_enabled = true
    S.watcher_gen = S.watcher_gen + 1
    tick_watch(S.watcher_gen)
    S.floor_scan_gen = S.floor_scan_gen + 1
    floor_scan_tick(S.floor_scan_gen)
end

local function stop_watcher()
    if not S.watcher_enabled then return end
    S.watcher_enabled = false
    S.watcher_gen = S.watcher_gen + 1
    S.floor_scan_gen = S.floor_scan_gen + 1
end

local function schedule_initial_force()
    S.init_force_gen = S.init_force_gen + 1
    local gen = S.init_force_gen
    dfhack.timeout(INITIAL_FORCE_DELAY_TICKS, "ticks", function()
        if gen ~= S.init_force_gen then return end
        if not dfhack.isMapLoaded() then return end
        convert_buildings(true, true)
    end)
end

local function status()
    log(("Status: debug=%s watcher=%s interval=%d last_map_key=%s"):format(
        tostring(S.debug), tostring(S.watcher_enabled), S.watcher_interval, tostring(S.last_map_key)))
end

local function inspect_tiles(radius)
    if not dfhack.isMapLoaded() then log("No map loaded.") return end
    local adv = dfhack.world.getAdventurer()
    if not adv or not adv.pos then log("No active adventurer.") return end
    local r = tonumber(radius) or 3
    local constructions = df.global.world.event.constructions
    local existing = {}
    for i = 0, #constructions - 1 do
        local c = constructions[i]
        existing[key_xyz(c.pos.x, c.pos.y, c.pos.z)] = c
    end
    local cx, cy, cz = adv.pos.x, adv.pos.y, adv.pos.z
    for dy = -r, r do
        for dx = -r, r do
            local x, y, z = cx + dx, cy + dy, cz
            local block = dfhack.maps.getTileBlock(x, y, z)
            if block then
                local lx, ly = x % 16, y % 16
                local tt = block.tiletype[lx][ly]
                local attrs = df.tiletype.attrs[tt]
                if attrs then
                    local shape_basic = attrs.shape
                    local shape_str = tostring(df.tiletype_shape_basic[shape_basic] or shape_basic)
                    if shape_str ~= "Open" and shape_str ~= "Floor" and shape_str ~= "None" then
                        local mat_str = tostring(df.tiletype_material[attrs.material] or attrs.material)
                        local name = tostring(df.tiletype[tt] or "tt_" .. tostring(tt))
                        local bld = block.occupancy[lx][ly].building
                        local outside = block.designation[lx][ly].outside
                        local c = existing[key_xyz(x, y, z)]
                        local cinfo = "none"
                        if c then
                            local itype = tostring(df.item_type[c.item_type] or c.item_type)
                            cinfo = ("mat=%d:%d item_type=%s"):format(c.mat_type, c.mat_index, itype)
                        end
                        log(("  [%d,%d,%d] %s | mat=%s shape=%s | out=%s bld=%d | cons: %s"):format(
                            x, y, z, name, mat_str, shape_str, tostring(outside), bld, cinfo))
                    end
                end
            end
        end
    end
end

local args = {...}
local cmd = args[1] or "enable"

if cmd == "enable" then
    convert_buildings(false)
    start_watcher()
    schedule_initial_force()
elseif cmd == "force" then
    convert_buildings(true)
elseif cmd == "inspect" then
    inspect_tiles(args[2])
elseif cmd == "diagwalls" then
    diag_walls(args[2])
elseif cmd == "disable" then
    S.init_force_gen = S.init_force_gen + 1
    S.floor_scan_gen = S.floor_scan_gen + 1
    stop_watcher()
    S.last_map_key = nil
    S.processed_blocks = {}
    S.last_site_id = nil
elseif cmd == "status" then
    status()
elseif cmd == "debug" then
    local mode = args[2] or "toggle"
    if mode == "on" then
        S.debug = true
    elseif mode == "off" then
        S.debug = false
    else
        S.debug = not S.debug
    end
    log("Debug " .. (S.debug and "ON" or "OFF"))
else
    log("Usage: building [enable|force|inspect [r]|diagwalls [r]|disable|status|debug [on|off]]")
end