Powah! Rearchitected BE

import { registerChargeable, registerContainerEntity } from "./powah\_compat.js";

registerChargeable("myaddon:jetpack", { capacity: 2\_000\_000 });

registerContainerEntity({ id: "myaddon:chest", entities: { types: \["myaddon:chest\_entity"\] } });

// ============================================================================================================================
// Powah! Bedrock - compat kit (a drop-in file for YOUR addon)
//
// Copy this file and powah_charge_compat.js into your addon's scripts/ folder, then import what you need in main.js:
// import { registerContainerEntity, registerEnergySystem, registerEnergyCable, registerItemCable, registerChargeable } from "./powah_compat.js";
//
// You don't need Powah installed for any of this. There's no import from it, no "is it there?" check, and nothing breaks without it. The only
// thing this touches is @minecraft/server. Every register*() call just sends a "powah_compat:register" script event, and if Powah isn't in the
// world nobody is listening, so nothing happens. We send the registrations again when Powah announces "powah_compat:ready", so it doesn't matter
// which addon loads first. Docs and examples are in the Compatibility section of the addon page.
// ============================================================================================================================
import { system, world } from "@minecraft/server";
import { announce } from "./powah_charge_compat.js";
export * from "./powah_charge_compat.js"; // registerChargeable, getItemEnergy, setItemEnergy, addItemEnergy, consumeItemEnergy, …
 
// ---------------------------------------------------------------- registrations (your addon -> Powah)
 
// 1) Chests/containers that are made of an ENTITY. Powah's Energy Hopper will charge any energy items sitting inside them.
// registerContainerEntity({ id, entities: { types?, families?, tags? }, blocks?: { ids?, tags? }, slots?, skipSlots? })
// entities how to recognize your entity (give at least one of the three)
// blocks (optional) only count it if the block the hopper is pointing at is one of these (block ids or block tags)
// slots (optional) only charge these slots
// skipSlots (optional) slots Powah should never touch (UI buttons, for example)
export function registerContainerEntity(def) { announce({ type: "container", …need(def, "entities") }); }
 
// 2) Energy system: entities from YOUR addon that keep their energy in scoreboards. Once they're registered, Powah machines and cables can
// send energy to them and pull energy from them.
// registerEnergySystem({ id, entities: { types?, families?, tags? }, blocks?: { ids?, tags? },
// objectives?: { energy, exp?, cap, capExp? }, ratio?, insert?, extract?, battery? })
// objectives your scoreboard names (defaults: energy / energyCap; "exp" and "capExp" are optional and store the value as x * 10^exp)
// ratio how many FE one unit of your energy is worth (default 1)
// insert/extract (default true) whether Powah is allowed to put energy into / take energy out of these entities
// battery (default false) set it to true for batteries, so a battery never feeds another battery
// blocks the blocks of those machines. Powah needs them to find a machine at the END of a registered cable network
export function registerEnergySystem(def) { announce({ type: "energy_system", …need(def, "entities") }); }
 
// 3) ENERGY cables from your addon: Powah walks along them starting from each of its machines, then pushes/pulls energy
// to/from the machines at the other end.
// registerEnergyCable({ id, blocks: { ids?, tags? } })
export function registerEnergyCable(def) { announce({ type: "energy_cable", …need(def, "blocks") }); }
 
// 4) ITEM cables/pipes from your addon: whenever a machine with item slots shows up or changes, Powah pings your network
// (powah_compat:updatePipes) so it can refresh its connections.
// registerItemCable({ id, blocks: { ids?, tags? } })
export function registerItemCable(def) { announce({ type: "item_cable", …need(def, "blocks") }); }
 
function need(def, key) {
  if (!def || typeof def.id !== "string" || !def[key]) throw new Error(`[powah-compat] a registration needs an "id" and "${key}"`);
  return def;
}
 
// ---------------------------------------------------------------- Powah machines (your addon <- Powah)
// Everything in here reads/writes the powah:machine_entity straight from the world (entities and scoreboards are shared between addons).
export const MACHINE_ENTITY = "powah:machine_entity";
export const isPowahMachine = (e) => e?.typeId === MACHINE_ENTITY;
// One-block machines keep their entity in the block itself. The Reactor (36 parts) keeps it in the CORE, and the entity carries a
// "dorios:link_node:[x,y,z]" tag for every part, so the lookup works from ANY part of the structure.
export function getMachineAt(dimension, loc) {
  const p = { x: Math.floor(loc.x), y: Math.floor(loc.y), z: Math.floor(loc.z) };
  const direct = dimension.getEntitiesAtBlockLocation(p).find(isPowahMachine);
  if (direct) return direct;
  return dimension.getEntities({ type: MACHINE_ENTITY, tags: [`dorios:link_node:[${p.x},${p.y},${p.z}]`] })[0];
}
// { kind: "furnator", tier: "blazing" } (the kind comes from the entity name, the tier from a tag)
export function getMachineInfo(e) {
  if (!isPowahMachine(e)) return undefined;
  const kind = /^entity\.powah:(.+?)(?:_(?:starter|basic|hardened|blazing|niotic|spirited|nitro|creative))?\.name$/.exec(e.nameTag ?? "")?.[1];
  return kind ? { kind, tier: e.getTags().find((t) => t.startsWith("powah:tier:"))?.slice(11) ?? "starter" } : undefined;
}
 
// -- items: Powah publishes each machine's slots in the entity tags "powah_io:in:2,3" and "powah_io:out:2,3"
const slotsFromTag = (e, prefix) => { const t = e.getTags().find((x) => x.startsWith(prefix)); return t ? t.slice(prefix.length).split(",").filter(Boolean).map(Number) : []; };
export function getItemIO(e) {
  if (!isPowahMachine(e) || !e.hasTag("powah_io:v1")) return undefined; // no item automation on this machine, or Powah hasn't published it yet (give it ~1 s)
  const limits = {}; // slot -> max items (Powah's default is 1 in the charge slots)
  for (const t of e.getTags()) if (t.startsWith("powah_io:max:")) { const [s, n] = t.slice(13).split(":").map(Number); limits[s] = n; }
  return { inputSlots: slotsFromTag(e, "powah_io:in:"), outputSlots: slotsFromTag(e, "powah_io:out:"), limits };
}
const cont = (e) => e.getComponent("minecraft:inventory")?.container;
// Puts (part of) a stack into the machine and returns how many items actually went in. Whatever is left stays with you.
// Powah doesn't check the item, it just uses what it understands.
export function insertItem(e, stack, opts = {}) {
  const io = getItemIO(e), c = io && cont(e);
  if (!io || !c || !stack) return 0;
  const slots = opts.slots ? io.inputSlots.filter((s) => opts.slots.includes(s)) : io.inputSlots;
  let left = Math.min(stack.amount, opts.maxAmount ?? stack.amount);
  const start = left;
  for (const s of slots) { // 1) top up the stacks that already match
    const cur = c.getItem(s), lim = Math.min(io.limits[s] ?? 64, stack.maxAmount);
    if (left <= 0 || !cur || !cur.isStackableWith(stack) || cur.amount >= lim) continue;
    const n = Math.min(left, lim - cur.amount);
    cur.amount += n; c.setItem(s, cur); left -= n;
  }
  for (const s of slots) { // 2) then fill the empty slots
    if (left <= 0 || c.getItem(s)) continue;
    const n = Math.min(left, io.limits[s] ?? 64, stack.maxAmount), put = stack.clone();
    put.amount = n; c.setItem(s, put); left -= n;
  }
  return start - left;
}
// Takes up to maxAmount items from the first output slot that has something in it. Returns the ItemStack you took (or undefined).
export function extractItem(e, opts = {}) {
  const io = getItemIO(e), c = io && cont(e);
  if (!io || !c) return undefined;
  const slots = opts.slots ? io.outputSlots.filter((s) => opts.slots.includes(s)) : io.outputSlots;
  for (const s of slots) {
    const cur = c.getItem(s);
    if (!cur) continue;
    const n = Math.min(cur.amount, opts.maxAmount ?? 64), out = cur.clone();
    out.amount = n;
    if (n >= cur.amount) c.setItem(s, undefined); else { cur.amount -= n; c.setItem(s, cur); }
    return out;
  }
  return undefined;
}
 
// -- energy (in FE, stored in the scoreboards energy / energyExp / energyCap / energyCapExp)
const obj = (n) => world.scoreboard.getObjective(n);
const score = (e, v, x) => { const id = e.scoreboardIdentity; return id ? (obj(v)?.getScore(id) ?? 0) * 10 ** (obj(x)?.getScore(id) ?? 0) : 0; };
export const getMachineEnergy = (e) => ({ stored: score(e, "energy", "energyExp"), cap: score(e, "energyCap", "energyCapExp") });
function setStored(e, fe) {
  let v = Math.max(0, fe), exp = 0;
  while (v > 1e9) { v /= 1e3; exp += 3; }
  obj("energy")?.setScore(e.scoreboardIdentity, Math.floor(v));
  obj("energyExp")?.setScore(e.scoreboardIdentity, exp);
}
// Adds energy, capped at the free space, and returns how much actually went in. Does it care about sides or redstone? Nope, that part is up to you.
export function addMachineEnergy(e, fe) {
  if (!isPowahMachine(e) || fe <= 0) return 0;
  const { stored, cap } = getMachineEnergy(e), n = Math.min(fe, Math.max(0, cap - stored));
  if (n > 0) setStored(e, stored + n);
  return n;
}
// Takes energy, all or nothing (just like Powah does it), and returns how much came out (0 if there wasn't enough). Creative machines always have it.
export function takeMachineEnergy(e, fe) {
  if (!isPowahMachine(e) || fe <= 0) return 0;
  if (e.hasTag("powah:creative"))