Nodeworks: FTB Evolution 2 config options

Whether the Grapple Beam can attach to and pull entities. Set to false to restrict grapples to terrain only.

Whether the Network Controller can force-load chunks. Disable to let another chunk-loading mod handle it. When false, the chunk- load toggle is hidden from the Controller's GUI and any existing claims drop on the next controller tick.

Items the User device refuses to drive. Bare ids match exactly, entries starting with `#` match an item tag (resolved against the active level's registry, so modded tags work without extra setup). Defaults block food and ranged-weapon abuse (auto-feed, auto-bow farms). Add `#c:tools/melee_weapon` to also block sword automation. Empty list = no restrictions.

Deny-list of script API methods. Format: "Type:method" exact match. Calling any of these from a script throws a Lua error. Type names: Network global network table (network:insert, network:tryInsert, etc.) Scheduler global scheduler table (scheduler:tick, second, delay, cancel) CardHandle storage card methods (insert, tryInsert, find, findEach, count, face, slots) RedstoneCard redstone card methods (powered, strength, set, onChange) ObserverCard observer card methods (block, state, onChange) VariableHandle variable card methods (get, set, cas, increment, decrement, etc.) PlacerHandle placer methods (place, block, isBlocked) BreakerHandle breaker methods (mine, cancel, block, state, isMining, progress) Recommended public-server posture: disabledMethods = ["CardHandle:insert", "Network:insert"] (forces scripts to use the partial-success tryInsert variants, which interact better with the per-tick item budget).

Optional Lua standard libraries to load on engine startup. Available: bit32 (bitwise ops), table, string, math. The base library (print, pairs, tostring, etc.) and the package library (required by `require`) load unconditionally. The `package` global itself is always nil'd so scripts can't reach package.loadlib / searchers. Comment out (delete) entries to strip individual libs.

When the top-level chunk soft-aborts, automatically clear `autoRun` on the terminal so the next world load doesn't re-trigger the bad script. Closes the per-chunk-load grief vector (a `while true do end` saved with autoRun on pinning the server tick on every restart). Recommended: true.

Max items moved per tick per network across all script insert and tryInsert calls. Independent of maxItemMoveCallsPerTick (a single call can move many items, so call count != item count). When exhausted, tryInsert silently moves what it can and insert fails with an error in the terminal. The default of 16384 is 256 full stacks per tick. 0 also means 16384, this one has no unlimited setting.

Wall-clock budget for each callback invocation (scheduler tick callbacks, redstone/observer onChange, processing handlers). Each invocation gets a fresh budget. A script that just registers handlers and exits consumes no budget while idle. On timeout the offending callback is evicted from its registry so it cannot re-fire next tick.

Total wall-clock budget for all Lua execution across every running engine per server tick. When this is exhausted, remaining engines are skipped entirely for this tick. Combined with localTickBudgetMs, this bounds the worst-case Lua time one server tick can spend on scripts regardless of how many engines are active.

How many Lua bytecode instructions between wall-clock checks inside the guarded debug hook. Lower = tighter timeout bounding when the script is in a tight loop calling slow Kotlin functions (the hook is starved while Lua is inside Kotlin code, so the check frequency caps how many slow calls slip past the budget). 32 keeps overhead negligible while bounding the per-iteration overrun tightly. Heavy compute scripts pay slightly more but absolute cost is microseconds per tick.

Per-engine wall-clock budget within a single server tick. When an engine exhausts this, remaining callbacks (scheduler tasks, redstone/observer pollers) defer to the next tick so the server stays responsive even if an engine has heavy work to do. A single callback that runs longer than this still completes (bounded by callbackSoftAbortMs cumulatively); the budget only applies between callbacks, not within them.

Max simultaneously-registered callbacks per kind per engine (scheduler tasks, redstone handlers, observer handlers, processing handlers, presets). The 257th registration throws a fatal Lua error and locks the terminal, so a recursive self-register pattern (a callback that registers another callback each time it fires) crashes loud rather than slowly bloating the registry. Per-engine because the registry is script-internal state.

Max error-log dispatches per tick per network. Same packet path as maxPrintsPerTick but for error-log calls (bug spam from a loop). Counted separately so legit error reporting isn't starved by a noisy script.

Max network/card insert/tryInsert/route calls per tick per network. Per-call cap, separate from maxItemsMovedPerTickPerNetwork which limits item count rather than call count. A single call can move a stack of 64; the call cap bounds packet flood from menu syncs, the item cap bounds bulk throughput.

Milliseconds per tick per network that tryInsert moves may spend, and the time each importer or stocker run gets. A move that runs out stops and keeps what already moved, the rest moves on later ticks. This is the backstop for storages slow enough that even maxItemsMovedPerTickPerNetwork items take too long, so it can't be turned off.

Max items one importer or stocker run moves. Separate from maxItemsMovedPerTickPerNetwork, each preset gets its own allowance per run. A run that hits it stops and the rest moves on later runs. 0, or anything above 16384, means 16384, this one has no unlimited setting.

Max script-driven block placements per tick per network (placer:place). Each placement fires a BlockUpdatePacket and neighbour updates; placement is heavy, so this cap is the lowest by default.

Max script `print(...)` calls per tick per network. Each print sends a chat packet to nearby players, so the actual shared resource is the player's network bandwidth, not any per-terminal channel. Per-network so a player can't multiply the cap by spreading bad scripts across N terminals.

Max script-driven redstone signal writes per tick per network (redstone:set). Each write triggers neighbour-change updates.

Max script-driven variable card writes per tick per network (var:set, var:cas). Each write fires setChanged + sendBlockUpdated.

Max range in blocks for the Grapple Beam's attach raycast.

Wall-clock budget for the top-level chunk (`main`) before the script is soft-aborted. Longer than the callback budget because legit setup work (building large route tables, seeding presets) can plausibly take several seconds. On timeout the terminal's `autoRun` flag is cleared and a `lastError` is persisted so the bad script doesn't re-fire on world load.