export const Skill = {
  ATTACK: "attack",
  STRENGTH: "strength",
  DEFENSE: "defense",
  RANGE: "ranged",
  MAGIC: "magic",
  CONSTITUTION: "constitution",
  PRAYER: "prayer",
  WOODCUTTING: "woodcutting",
  MINING: "mining",
  FISHING: "fishing",
  FIREMAKING: "firemaking",
  COOKING: "cooking",
  SMITHING: "smithing",
  AGILITY: "agility",
  CRAFTING: "crafting",
  FLETCHING: "fletching",
  RUNECRAFTING: "runecrafting",
};

const skillsSystem = world.getSystem('skills') as SkillsSystem;
skillsSystem.grantXP(playerId, Skill.FLETCHING, 5);

const level = skillsSystem.getLevelForXP(13034); // 30

const xp = skillsSystem.getXPForLevel(50); // 101333

const canSmith = skillsSystem.meetsRequirements(player, {
  smithing: 40,
  mining: 30
});

import { processingDataProvider } from '@hyperscape/shared';

// Called automatically by DataManager
processingDataProvider.initialize();

// Check if ready
if (processingDataProvider.isReady()) {
  // Use provider
}

{
  rawItemId: string;
  cookedItemId: string;
  burntItemId: string;
  levelRequired: number;
  xp: number;
  stopBurnLevel: { fire: number; range: number };
}

{
  itemId: string;
  name: string;
  barType: string;
  barsRequired: number;
  levelRequired: number;
  xp: number;
  category: SmithingCategory;
  ticks: number;
  outputQuantity: number; // 1 for most items, 15 for arrowtips
}

{
  ...SmithingRecipeData,
  meetsLevel: boolean; // Player has sufficient level
  hasBars: boolean;    // Player has enough bars
}

{
  barItemId: string;
  primaryOre: string;
  secondaryOre: string | null;
  coalRequired: number;
  levelRequired: number;
  xp: number;
  successRate: number;
  ticks: number;
}

{
  output: string;
  name: string;
  category: string;
  inputs: Array<{ item: string; amount: number }>;
  tools: string[];
  consumables: Array<{ item: string; uses: number }>;
  level: number;
  xp: number;
  ticks: number;
  station: string; // "none" or "furnace"
}

const needleInputs = processingDataProvider.getCraftingInputsForTool('needle');
// Returns: Set(['leather', 'green_dragon_leather', ...])

{
  recipeId: string;
  output: string;
  name: string;
  outputQuantity: number; // 1 for bows, 15 for arrow shafts
  category: string;
  inputs: Array<{ item: string; amount: number }>;
  tools: string[];
  level: number;
  xp: number;
  ticks: number;
}

const logRecipes = processingDataProvider.getFletchingRecipesForInput('logs');
// Returns recipes for arrow shafts, shortbow_u, etc.

const stringRecipes = processingDataProvider.getFletchingRecipesForInputPair(
  'shortbow_u',
  'bowstring'
);
// Returns stringing recipe

const knifeInputs = processingDataProvider.getFletchingInputsForTool('knife');
// Returns: Set(['logs', 'oak_logs', 'willow_logs', ...])

{
  runeType: string;
  runeItemId: string;
  name: string;
  levelRequired: number;
  xpPerEssence: number;
  essenceTypes: string[]; // ["rune_essence", "pure_essence"]
  multiRuneLevels: number[]; // Sorted ascending
}

const multiplier = processingDataProvider.getRunecraftingMultiplier('air', 22);
// Returns: 3 (base 1 + thresholds at 11 and 22)

{
  input: string;
  output: string;
  cost: number;
  name: string;
}

{
  cookableItems: number;
  burnableLogs: number;
  smeltableBars: number;
  smithingRecipes: number;
  craftingRecipes: number;
  tanningRecipes: number;
  fletchingRecipes: number;
  runecraftingRecipes: number;
  isInitialized: boolean;
}

1. Player clicks needle on leather
   → CRAFTING_INTERACT

2. System validates and emits CRAFTING_INTERFACE_OPEN
   → Client shows CraftingPanel

3. Player selects recipe and quantity
   → PROCESSING_CRAFTING_REQUEST

4. System creates session with completionTick

5. Every tick, check if currentTick >= completionTick
   → If yes, complete one craft action

6. On completion:
   - Consume materials
   - Decrement thread uses (consume thread every 5 crafts)
   - Add crafted item
   - Grant XP
   - Play animation
   - Schedule next craft or complete session

7. Cancel on movement/combat

// Add fletched items with outputQuantity
this.emitTypedEvent(EventType.INVENTORY_ITEM_ADDED, {
  playerId,
  item: {
    id: `fletch_${playerId}_${++this.fletchCounter}_${Date.now()}`,
    itemId: recipe.output,
    quantity: recipe.outputQuantity, // 15 for arrow shafts
    slot: -1,
    metadata: null,
  },
});

1. Player clicks air altar
   → RUNECRAFTING_INTERACT { runeType: "air" }

2. System validates:
   - Recipe exists for rune type
   - Player meets level requirement
   - Player has valid essence in inventory

3. Count all essence in inventory (rune_essence + pure_essence)

4. Calculate multiplier based on player level
   - Level 1-10: 1 rune per essence
   - Level 11-21: 2 runes per essence
   - Level 22-32: 3 runes per essence
   - etc.

5. Instantly:
   - Remove ALL essence from inventory
   - Add (essence count * multiplier) runes
   - Grant (essence count * xpPerEssence) XP
   - Emit RUNECRAFTING_COMPLETE

6. Show success message with multiplier info

Player has 28 rune essence, level 22 runecrafting
Clicks air altar
→ Removes 28 rune essence
→ Adds 84 air runes (28 * 3)
→ Grants 140 XP (28 * 5)
→ Message: "You craft 84 air runes (3x multiplier)."

new RunecraftingAltarEntity(world: World, config: RunecraftingAltarEntityConfig)

{
  id: string;
  name?: string; // Default: "{RuneType} Altar"
  position: { x: number; y: number; z: number };
  rotation?: { x: number; y: number; z: number };
  footprint?: FootprintSpec; // Collision footprint
  runeType: string; // "air", "water", "fire", etc.
}

[
  {
    id: "craft_rune",
    label: "Craft-rune",
    priority: 1,
    handler: () => { /* Emit RUNECRAFTING_INTERACT */ }
  },
  {
    id: "examine",
    label: "Examine",
    priority: 100,
    handler: () => { /* Show examine text */ }
  }
]

air:    { core: 0xffffff, mid: 0xe0e8f0, outer: 0xc8d8e8 }
water:  { core: 0x80d0ff, mid: 0x2090e0, outer: 0x1060c0 }
earth:  { core: 0x80ff80, mid: 0x30a030, outer: 0x208020 }
fire:   { core: 0xff6040, mid: 0xe02020, outer: 0xb01010 }
mind:   { core: 0xe879f9, mid: 0xa855f7, outer: 0x7c3aed }
chaos:  { core: 0xff6b6b, mid: 0xdc2626, outer: 0x991b1b }
// ... etc.

{
  playerId: string;
  triggerType: string; // "needle", "chisel", "furnace"
  stationId?: string;
  inputItemId?: string;
}

{
  playerId: string;
  availableRecipes: Array<{
    output: string;
    name: string;
    category: string;
    inputs: Array<{ item: string; amount: number }>;
    tools: string[];
    level: number;
    xp: number;
    meetsLevel: boolean;
    hasInputs: boolean;
  }>;
  station: string;
}

{
  playerId: string;
  recipeId: string; // Output item ID
  quantity: number;
}

{
  playerId: string;
  recipeId: string;
}

{
  playerId: string;
  recipeId: string;
  outputItemId: string;
  totalCrafted: number;
  totalXp: number;
}

{
  playerId: string;
  triggerType: string; // "knife"
  inputItemId: string;
  secondaryItemId?: string; // For item-on-item
}

{
  playerId: string;
  availableRecipes: Array<{
    recipeId: string;
    output: string;
    name: string;
    category: string;
    outputQuantity: number;
    inputs: Array<{ item: string; amount: number }>;
    tools: string[];
    level: number;
    xp: number;
    meetsLevel: boolean;
    hasInputs: boolean;
  }>;
}

{
  playerId: string;
  recipeId: string; // Format: "output:primaryInput"
  quantity: number;
}

{
  playerId: string;
  recipeId: string;
}

{
  playerId: string;
  recipeId: string;
  outputItemId: string;
  totalCrafted: number;
  totalXp: number;
}

{
  playerId: string;
  altarId: string;
  runeType: string; // "air", "water", etc.
}

{
  playerId: string;
  runeType: string;
  runeItemId: string;
  essenceConsumed: number;
  runesProduced: number;
  multiplier: number;
  xpAwarded: number;
}

interface SkillData {
  level: number; // 1-99
  xp: number;    // 0-200,000,000
}

interface Skills {
  attack: SkillData;
  strength: SkillData;
  defense: SkillData;
  constitution: SkillData;
  ranged: SkillData;
  magic: SkillData;
  prayer: SkillData;
  woodcutting: SkillData;
  mining: SkillData;
  fishing: SkillData;
  firemaking: SkillData;
  cooking: SkillData;
  smithing: SkillData;
  agility: SkillData;
  crafting: SkillData;
  fletching: SkillData;
  runecrafting: SkillData;
}

type SmithingCategory = 
  | "weapons"
  | "armor"
  | "tools"
  | "arrowtips"
  | "nails"
  | "other";

type FootprintSpec = 
  | { x: number; z: number }  // Explicit size
  | "1x1" | "2x2" | "3x3"     // Preset sizes
  | number;                    // Square size

import { processingDataProvider } from '@hyperscape/shared';

function canPlayerCraft(playerId: string, itemId: string): boolean {
  const recipe = processingDataProvider.getCraftingRecipe(itemId);
  if (!recipe) return false;
  
  const player = world.getPlayer(playerId);
  const craftingLevel = player.skills.crafting.level;
  
  if (craftingLevel < recipe.level) return false;
  
  const inventory = world.getInventory(playerId);
  const invState = buildInventoryState(inventory);
  
  return hasRequiredInputs(invState, recipe) &&
         hasRequiredTools(invState, recipe) &&
         hasRequiredConsumables(invState, recipe);
}

import { processingDataProvider } from '@hyperscape/shared';

function calculateRunecraftingOutput(
  runeType: string,
  essenceCount: number,
  playerLevel: number
): { runes: number; xp: number } {
  const recipe = processingDataProvider.getRunecraftingRecipe(runeType);
  if (!recipe) return { runes: 0, xp: 0 };
  
  const multiplier = processingDataProvider.getRunecraftingMultiplier(
    runeType,
    playerLevel
  );
  
  return {
    runes: essenceCount * multiplier,
    xp: essenceCount * recipe.xpPerEssence
  };
}

// Example usage
const output = calculateRunecraftingOutput('air', 28, 22);
// Returns: { runes: 84, xp: 140 }

import { processingDataProvider } from '@hyperscape/shared';

function getFletchingOptionsForLogs(
  logItemId: string,
  playerLevel: number
): FletchingRecipeData[] {
  const recipes = processingDataProvider.getFletchingRecipesForInput(logItemId);
  
  return recipes.filter(recipe => recipe.level <= playerLevel);
}

// Example usage
const options = getFletchingOptionsForLogs('oak_logs', 20);
// Returns: [arrow_shaft recipe, oak_shortbow_u recipe]

import { processingDataProvider } from '@hyperscape/shared';

function getSmithingPanelData(
  inventory: InventoryItem[],
  smithingLevel: number
) {
  const recipes = processingDataProvider.getSmithableItemsWithAvailability(
    inventory,
    smithingLevel
  );
  
  // Group by category
  const grouped = new Map<SmithingCategory, typeof recipes>();
  for (const recipe of recipes) {
    const categoryRecipes = grouped.get(recipe.category) || [];
    categoryRecipes.push(recipe);
    grouped.set(recipe.category, categoryRecipes);
  }
  
  return grouped;
}

// UI can show:
// - Green highlight: meetsLevel && hasBars
// - Red highlight: !meetsLevel
// - Gray: meetsLevel && !hasBars

// ProcessingDataProvider uses pre-allocated Map for inventory counting
private readonly inventoryCountBuffer = new Map<string, number>();

// Reused across multiple method calls to avoid allocations
private buildInventoryCounts(inventory): Map<string, number> {
  this.inventoryCountBuffer.clear();
  // ... populate buffer
  return this.inventoryCountBuffer;
}

// FletchingSystem uses reusable array for tick processing
private readonly completedPlayerIds: string[] = [];

update(_dt: number): void {
  this.completedPlayerIds.length = 0; // Clear without allocating
  // ... collect completed sessions
  for (const playerId of this.completedPlayerIds) {
    this.completeFletch(playerId);
  }
}

private lastProcessedTick = -1;

update(_dt: number): void {
  const currentTick = this.world.currentTick ?? 0;
  
  // Only process once per tick (avoid duplicate processing)
  if (currentTick === this.lastProcessedTick) return;
  this.lastProcessedTick = currentTick;
  
  // ... process sessions
}

// Collect all completed sessions first, then process
// Avoids modifying Map while iterating
const completedPlayerIds: string[] = [];
for (const [playerId, session] of this.activeSessions) {
  if (currentTick >= session.completionTick) {
    completedPlayerIds.push(playerId);
  }
}
for (const playerId of completedPlayerIds) {
  this.completeAction(playerId);
}

// Cache player skills to avoid repeated entity lookups
private readonly playerSkills = new Map<
  string,
  Record<string, { level: number; xp: number }>
>();

// Update cache on SKILLS_UPDATED event
this.subscribe(EventType.SKILLS_UPDATED, (data) => {
  this.playerSkills.set(data.playerId, data.skills);
});

// Use cached value
private getCraftingLevel(playerId: string): number {
  const cached = this.playerSkills.get(playerId);
  if (cached?.crafting?.level != null) {
    return cached.crafting.level;
  }
  // Fallback to entity lookup
  // ...
}

cd packages/server
bunx drizzle-kit migrate

for (const consumable of recipe.consumables) {
  const remaining = session.consumableUses.get(consumable.item) || 0;
  session.consumableUses.set(consumable.item, Math.max(0, remaining - 1));
}

{
  "multiRuneLevels": [11, 22, 33, 44, 55, 66, 77, 88, 99]
}

this.emitTypedEvent(EventType.INVENTORY_ITEM_ADDED, {
  playerId,
  item: {
    id: `fletch_${playerId}_${++this.fletchCounter}_${Date.now()}`,
    itemId: recipe.output,
    quantity: recipe.outputQuantity, // NOT hardcoded 1
    slot: -1,
    metadata: null,
  },
});