XP for level N = floor(N + 300 * 2^(N/7)) / 4

{
  "raw": "raw_shrimp",
  "cooked": "shrimp",
  "burnt": "burnt_shrimp",
  "level": 1,
  "xp": 30,
  "ticks": 4,
  "stopBurnLevel": { "fire": 35, "range": 32 }
}

{
  "output": "bronze_bar",
  "inputs": [
    { "item": "copper_ore", "amount": 1 },
    { "item": "tin_ore", "amount": 1 }
  ],
  "level": 1,
  "xp": 6.25,
  "ticks": 4,
  "successRate": 1.0
}

{
  "output": "bronze_sword",
  "bar": "bronze_bar",
  "barsRequired": 1,
  "level": 4,
  "xp": 12.5,
  "ticks": 4,
  "category": "weapons"
}

{
  "output": "leather_body",
  "category": "leather",
  "inputs": [{ "item": "leather", "amount": 14 }],
  "tools": ["needle"],
  "consumables": [{ "item": "thread", "uses": 5 }],
  "level": 14,
  "xp": 25,
  "ticks": 3,
  "station": "none"
}

{
  "output": "arrow_shaft",
  "outputQuantity": 15,
  "category": "arrow_shafts",
  "inputs": [{ "item": "logs", "amount": 1 }],
  "tools": ["knife"],
  "level": 1,
  "xp": 5,
  "ticks": 2,
  "skill": "fletching"
}

{
  "runeType": "air",
  "runeItemId": "air_rune",
  "levelRequired": 1,
  "xpPerEssence": 5,
  "essenceTypes": ["rune_essence", "pure_essence"],
  "multiRuneLevels": [11, 22, 33, 44, 55, 66, 77, 88, 99]
}

{
  "input": "cowhide",
  "output": "leather",
  "cost": 1,
  "name": "Leather"
}

{
  level: 14,
  description: "Craft leather body armor",
  type: "item"
}

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

// Called automatically by DataManager after loading manifests
processingDataProvider.initialize();

// Check if item is cookable
processingDataProvider.isCookable('raw_shrimp'); // true

// Get cooking data
const data = processingDataProvider.getCookingData('raw_shrimp');
// Returns: { rawItemId, cookedItemId, burntItemId, levelRequired, xp, stopBurnLevel }

// Get all cookable items
const cookableIds = processingDataProvider.getCookableItemIds(); // Set<string>

// Get specific properties
const cookedId = processingDataProvider.getCookedItemId('raw_shrimp'); // 'shrimp'
const burntId = processingDataProvider.getBurntItemId('raw_shrimp'); // 'burnt_shrimp'
const level = processingDataProvider.getCookingLevel('raw_shrimp'); // 1
const xp = processingDataProvider.getCookingXP('raw_shrimp'); // 30
const stopBurn = processingDataProvider.getStopBurnLevel('raw_shrimp', 'fire'); // 35

// Check if item is smithable
processingDataProvider.isSmithableItem('bronze_sword'); // true

// Get smithing recipe
const recipe = processingDataProvider.getSmithingRecipe('bronze_sword');
// Returns: { itemId, name, barType, barsRequired, levelRequired, xp, category, ticks, outputQuantity }

// Get recipes for a bar type
const bronzeRecipes = processingDataProvider.getSmithingRecipesForBar('bronze_bar');

// Get recipes grouped by category
const grouped = processingDataProvider.getSmithingRecipesByCategory('bronze_bar');
// Returns: Map<SmithingCategory, SmithingRecipeData[]>

// Get available recipes for player level
const available = processingDataProvider.getAvailableSmithingRecipes(40);

// Get smithable items from inventory (with availability flags)
const smithable = processingDataProvider.getSmithableItemsWithAvailability(
  inventory,
  smithingLevel
);
// Returns: SmithingRecipeWithAvailability[] (includes meetsLevel, hasBars flags)

// Check if item is a smeltable bar
processingDataProvider.isSmeltableBar('bronze_bar'); // true

// Check if item is a smeltable ore
processingDataProvider.isSmeltableOre('copper_ore'); // true

// Get smelting data
const data = processingDataProvider.getSmeltingData('bronze_bar');
// Returns: { barItemId, primaryOre, secondaryOre, coalRequired, levelRequired, xp, successRate, ticks }

// Get all smeltable bars from inventory
const smeltable = processingDataProvider.getSmeltableBarsFromInventory(
  inventory,
  smithingLevel
);

// Check if item is craftable
processingDataProvider.isCraftableItem('leather_body'); // true

// Get crafting recipe
const recipe = processingDataProvider.getCraftingRecipe('leather_body');
// Returns: { output, name, category, inputs, tools, consumables, level, xp, ticks, station }

// Get recipes by category
const leatherRecipes = processingDataProvider.getCraftingRecipesByCategory('leather');

// Get recipes by station
const furnaceRecipes = processingDataProvider.getCraftingRecipesByStation('furnace');

// Get valid inputs for a tool
const needleInputs = processingDataProvider.getCraftingInputsForTool('needle');
// Returns: Set<string> of item IDs that can be crafted with needle

// Check if item is a crafting input
processingDataProvider.isCraftingInput('leather'); // true

// Get tool required for an input
const tool = processingDataProvider.getCraftingToolForInput('leather'); // 'needle'

// Check if item is fletchable
processingDataProvider.isFletchableItem('arrow_shaft'); // true

// Get fletching recipe by unique ID (output:primaryInput)
const recipe = processingDataProvider.getFletchingRecipe('arrow_shaft:logs');
// Returns: { recipeId, output, name, outputQuantity, category, inputs, tools, level, xp, ticks }

// Get recipes for a specific input item
const logRecipes = processingDataProvider.getFletchingRecipesForInput('logs');

// Get recipes for item-on-item interactions (both inputs required)
const stringRecipes = processingDataProvider.getFletchingRecipesForInputPair(
  'shortbow_u',
  'bowstring'
);

// Get valid inputs for a tool
const knifeInputs = processingDataProvider.getFletchingInputsForTool('knife');

// Get recipes by category
const arrowRecipes = processingDataProvider.getFletchingRecipesByCategory('arrows');

// Get runecrafting recipe by rune type
const recipe = processingDataProvider.getRunecraftingRecipe('air');
// Returns: { runeType, runeItemId, name, levelRequired, xpPerEssence, essenceTypes, multiRuneLevels }

// Check if item is essence
processingDataProvider.isRunecraftingEssence('rune_essence'); // true

// Calculate multi-rune multiplier for a level
const multiplier = processingDataProvider.getRunecraftingMultiplier('air', 22);
// Returns: 3 (base + 2 thresholds at levels 11 and 22)

// Get all runecrafting recipes
const allRecipes = processingDataProvider.getAllRunecraftingRecipes();

// Get tanning recipe
const recipe = processingDataProvider.getTanningRecipe('cowhide');
// Returns: { input, output, cost, name }

// Check if item can be tanned
processingDataProvider.isTannableItem('cowhide'); // true

// Get all tanning recipes
const allRecipes = processingDataProvider.getAllTanningRecipes();

// Grant XP to a skill
skillsSystem.grantXP(playerId, 'attack', 100);

// Get level for XP amount
const level = skillsSystem.getLevelForXP(13034); // 30

// Get XP required for level
const xp = skillsSystem.getXPForLevel(50); // 101333

// Check skill requirements
const meetsReqs = skillsSystem.meetsRequirements(entity, {
  smithing: 40,
  mining: 30
});

// Get combat level
const combatLevel = skillsSystem.getCombatLevel(stats);

// Get total level
const totalLevel = skillsSystem.getTotalLevel(stats);

// Player clicks needle on leather
world.emit(EventType.CRAFTING_INTERACT, {
  playerId: 'player123',
  triggerType: 'needle',
  inputItemId: 'leather'
});

// System shows available recipes
// Player selects "leather_body" and quantity 5

world.emit(EventType.PROCESSING_CRAFTING_REQUEST, {
  playerId: 'player123',
  recipeId: 'leather_body',
  quantity: 5
});

// System creates session, processes every 3 ticks until complete or interrupted

-- Combat
attackLevel, attackXp
strengthLevel, strengthXp
defenseLevel, defenseXp
constitutionLevel, constitutionXp
rangedLevel, rangedXp
magicLevel, magicXp
prayerLevel, prayerXp

-- Gathering
woodcuttingLevel, woodcuttingXp
miningLevel, miningXp
fishingLevel, fishingXp

-- Production
firemakingLevel, firemakingXp
cookingLevel, cookingXp
smithingLevel, smithingXp
agilityLevel, agilityXp
craftingLevel, craftingXp
fletchingLevel, fletchingXp
runecraftingLevel, runecraftingXp

export const Skill = {
  // ... existing skills
  HERBLORE: "herblore" as keyof Skills,
};

export interface Skills {
  // ... existing skills
  herblore: SkillData;
}

const skills: (keyof Skills)[] = [
  // ... existing skills
  Skill.HERBLORE,
];

{
  "recipes": [
    {
      "output": "attack_potion",
      "inputs": [
        { "item": "guam_leaf", "amount": 1 },
        { "item": "eye_of_newt", "amount": 1 }
      ],
      "level": 3,
      "xp": 25,
      "ticks": 2
    }
  ]
}

private herbloreManifest: HerbloreManifest | null = null;
private herbloreRecipeMap = new Map<string, HerbloreRecipeData>();

public loadHerbloreRecipes(manifest: HerbloreManifest): void {
  this.herbloreManifest = manifest;
}

private buildHerbloreDataFromManifest(): void {
  // Build lookup tables from manifest
}

public getHerbloreRecipe(outputItemId: string): HerbloreRecipeData | null {
  return this.herbloreRecipeMap.get(outputItemId) || null;
}

ALTER TABLE "characters" ADD COLUMN IF NOT EXISTS "herbloreLevel" integer DEFAULT 1;
ALTER TABLE "characters" ADD COLUMN IF NOT EXISTS "herbloreXp" integer DEFAULT 0;

export const SKILL_ICONS: Record<string, string> = {
  // ... existing skills
  herblore: "🧪",
};

export const SKILL_UNLOCKS: Record<string, readonly SkillUnlock[]> = {
  // ... existing skills
  herblore: [
    { level: 3, description: "Brew attack potions", type: "item" },
    // ... more unlocks
  ],
};

world.addSystem(new HerbloreSystem(world));

test('fletching produces 15 arrow shafts per log', async () => {
  const world = await createTestWorld();
  const player = createTestPlayer(world, { fletching: { level: 1, xp: 0 } });
  
  // Add materials
  addInventoryItem(player, 'logs', 1);
  addInventoryItem(player, 'knife', 1);
  
  // Start fletching
  world.emit(EventType.FLETCHING_INTERACT, {
    playerId: player.id,
    triggerType: 'knife',
    inputItemId: 'logs'
  });
  
  // Select recipe
  world.emit(EventType.PROCESSING_FLETCHING_REQUEST, {
    playerId: player.id,
    recipeId: 'arrow_shaft:logs',
    quantity: 1
  });
  
  // Advance ticks
  advanceTicks(world, 2);
  
  // Verify output
  expect(getInventoryItem(player, 'arrow_shaft').quantity).toBe(15);
  expect(getInventoryItem(player, 'logs')).toBeUndefined();
});

// Pre-allocated buffer (class field)
private readonly completedPlayerIds: string[] = [];

update(_dt: number): void {
  const currentTick = this.world.currentTick ?? 0;
  
  // Only process once per tick
  if (currentTick === this.lastProcessedTick) return;
  this.lastProcessedTick = currentTick;
  
  // Collect completed sessions (reuse array)
  this.completedPlayerIds.length = 0;
  for (const [playerId, session] of this.activeSessions) {
    if (currentTick >= session.completionTick) {
      this.completedPlayerIds.push(playerId);
    }
  }
  
  // Process completions
  for (const playerId of this.completedPlayerIds) {
    this.completeFletch(playerId);
  }
}

<SkillGuidePanel
  visible={isOpen}
  skillLabel="Fletching"
  skillIcon="🏹"
  playerLevel={45}
  unlocks={SKILL_UNLOCKS.fletching}
  isLoading={false}
  onClose={() => setIsOpen(false)}
/>

1. Player clicks needle on leather
   → CRAFTING_INTERACT event

2. CraftingSystem validates and shows recipes
   → CRAFTING_INTERFACE_OPEN event

3. Client displays CraftingPanel with available recipes

4. Player selects "leather_body" and quantity 5
   → PROCESSING_CRAFTING_REQUEST event

5. CraftingSystem creates session, sets completionTick

6. Every tick, system checks if currentTick >= completionTick

7. On completion:
   → INVENTORY_ITEM_REMOVED (consume materials)
   → INVENTORY_ITEM_ADDED (add crafted item)
   → SKILLS_XP_GAINED (grant XP)
   → ANIMATION_PLAY (crafting animation)
   → UI_MESSAGE (success message)

8. Repeat steps 6-7 until quantity reached or interrupted

9. On session end:
   → CRAFTING_COMPLETE event

1. Player clicks air altar
   → RUNECRAFTING_INTERACT event

2. RunecraftingSystem validates essence and level

3. Calculate multi-rune multiplier based on level

4. Instantly:
   → INVENTORY_ITEM_REMOVED (all essence)
   → INVENTORY_ITEM_ADDED (runes = essence * multiplier)
   → SKILLS_XP_GAINED (XP = essence * xpPerEssence)
   → RUNECRAFTING_COMPLETE event
   → UI_MESSAGE (success message)

// ❌ BAD: Assume materials still exist
this.consumeMaterials(playerId, recipe);

// ✅ GOOD: Re-validate before consuming
const invState = this.getInventoryState(playerId);
if (!this.hasRequiredInputs(invState, recipe)) {
  this.cancelSession(playerId);
  return;
}
this.consumeMaterials(playerId, recipe);

// ❌ BAD: Hardcoded data
const BRONZE_SWORD_XP = 12.5;

// ✅ GOOD: Load from manifest
const recipe = processingDataProvider.getSmithingRecipe('bronze_sword');
const xp = recipe?.xp ?? 0;