@its-not-rocket-science/ananke 0.1.0

package/dist/src/crafting/manufacturing.js

@@ -0,0 +1,165 @@
+// src/crafting/manufacturing.ts — Phase 61: Manufacturing System
+//
+// Batch production lines, progress accumulation, quality variance.
+// Deterministic batch quality range based on workers, materials, workshop.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Default progress per worker per second (Q units). */
+const PROGRESS_PER_WORKER_PER_SECOND = q(0.001);
+/** Quality variance factor based on number of workers (more workers → less variance). */
+const WORKER_VARIANCE_REDUCTION = q(0.10);
+/** Minimum quality variance per batch. */
+const MIN_QUALITY_VARIANCE = q(0.05);
+// ── Production Line Management ────────────────────────────────────────────────
+/**
+ * Initialize a production line for batch manufacturing.
+ */
+export function setupProductionLine(order, workers, seed) {
+    const workerIds = workers.map(w => w.id);
+    const qualityRange = calculateBatchQualityRange(workers, order.workshop, seed);
+    return {
+        lineId: `line_${order.orderId}`,
+        recipeId: order.recipeId,
+        batchSize: order.quantity,
+        itemsProduced: 0,
+        progress_Q: q(0),
+        assignedWorkers: workerIds,
+        priority: 1,
+        qualityRange,
+    };
+}
+/**
+ * Advance production line by deltaTime seconds.
+ * Progress accumulates based on number of workers and their skills.
+ * Returns new items completed and updated progress.
+ */
+export function advanceProduction(productionLine, deltaTime_s, workers, // Must match assignedWorkers IDs
+workshop, seed) {
+    if (productionLine.itemsProduced >= productionLine.batchSize) {
+        return {
+            itemsCompleted: 0,
+            totalItemsProduced: productionLine.itemsProduced,
+            progress_Q: productionLine.progress_Q,
+            qualityRange: productionLine.qualityRange,
+        };
+    }
+    // Calculate total progress contribution from workers
+    let totalProgress = 0;
+    for (const worker of workers) {
+        const skill = worker.attributes.cognition?.bodilyKinesthetic ?? q(0.50);
+        // Progress = skill × time × base rate
+        const workerProgress = mulDiv(skill, deltaTime_s * SCALE.Q, 3600);
+        totalProgress += workerProgress;
+    }
+    // Apply workshop time reduction (not yet implemented)
+    const effectiveProgress = totalProgress; // placeholder
+    // Advance progress
+    let newProgress = productionLine.progress_Q + effectiveProgress;
+    let itemsCompleted = 0;
+    // Each item requires SCALE.Q progress
+    while (newProgress >= SCALE.Q && productionLine.itemsProduced < productionLine.batchSize) {
+        newProgress -= SCALE.Q;
+        itemsCompleted++;
+        productionLine.itemsProduced++;
+    }
+    productionLine.progress_Q = clampQ(newProgress, q(0), SCALE.Q);
+    // Update quality range based on remaining workers (variance reduces as more items produced)
+    const remainingItems = productionLine.batchSize - productionLine.itemsProduced;
+    const updatedRange = updateQualityRange(productionLine.qualityRange, workers, remainingItems, seed);
+    return {
+        itemsCompleted,
+        totalItemsProduced: productionLine.itemsProduced,
+        progress_Q: productionLine.progress_Q,
+        qualityRange: updatedRange,
+    };
+}
+/**
+ * Calculate predicted quality range for a batch based on workers, materials, workshop.
+ * Returns min, max, and average expected quality.
+ */
+export function calculateBatchQualityRange(workers, workshop, seed) {
+    if (workers.length === 0) {
+        return { min_Q: q(0), max_Q: q(0), avg_Q: q(0) };
+    }
+    // Average worker skill (bodilyKinesthetic)
+    let totalSkill = 0;
+    for (const worker of workers) {
+        totalSkill += worker.attributes.cognition?.bodilyKinesthetic ?? q(0.50);
+    }
+    const avgSkill = totalSkill / workers.length;
+    // Workshop quality bonus (placeholder)
+    const workshopBonus = q(1.0); // TODO: get from workshop
+    // Base average quality = avgSkill × workshopBonus
+    const avg_Q = clampQ(qMul(avgSkill, workshopBonus), q(0), SCALE.Q);
+    // Variance decreases with more workers
+    const variance = Math.max(MIN_QUALITY_VARIANCE, q(0.20) - mulDiv(WORKER_VARIANCE_REDUCTION, workers.length, 1));
+    const min_Q = clampQ((avg_Q - variance), q(0), SCALE.Q);
+    const max_Q = clampQ((avg_Q + variance), q(0), SCALE.Q);
+    return { min_Q, max_Q, avg_Q };
+}
+/** Update quality range as production progresses (variance may change). */
+function updateQualityRange(currentRange, workers, remainingItems, seed) {
+    // For simplicity, keep range constant; could adjust based on worker fatigue, etc.
+    return currentRange;
+}
+// ── Multi‑Stage Assembly ──────────────────────────────────────────────────────
+/**
+ * Create assembly steps for a complex recipe.
+ */
+export function createAssemblySteps(recipe) {
+    // Placeholder: generate steps based on recipe complexity
+    const steps = [];
+    const stepCount = Math.max(1, Math.round(recipe.complexity_Q / q(0.30)));
+    for (let i = 0; i < stepCount; i++) {
+        steps.push({
+            stepId: `step_${i}`,
+            description: `Step ${i + 1}`,
+            requiredSkill: i % 2 === 0 ? "bodilyKinesthetic" : "logicalMathematical",
+            timeFraction: Math.round(SCALE.Q / stepCount),
+            toolRequirements: i === 0 ? ["forge"] : [],
+        });
+    }
+    return steps;
+}
+/**
+ * Advance a single assembly step.
+ */
+export function advanceAssemblyStep(step, worker, deltaTime_s, availableTools) {
+    const skill = (worker.attributes.cognition?.[step.requiredSkill] ?? q(0.50));
+    const toolBonus = step.toolRequirements.length > 0
+        ? Math.max(...step.toolRequirements.map(t => availableTools.get(t) ?? q(0)))
+        : q(1.0);
+    const progress = mulDiv(skill, deltaTime_s * SCALE.Q, 3600);
+    const effectiveProgress = qMul(progress, toolBonus);
+    // Step requires timeFraction of total time to complete
+    const requiredProgress = step.timeFraction;
+    const newProgress = effectiveProgress; // accumulate across calls (needs state)
+    const completed = newProgress >= requiredProgress;
+    return { progress_Q: effectiveProgress, completed };
+}
+// ── Utility Functions ────────────────────────────────────────────────────────
+/** Estimate time to complete a batch given workers and workshop. */
+export function estimateBatchCompletionTime(batchSize, workers, workshop) {
+    if (workers.length === 0)
+        return Infinity;
+    let totalSkill = 0;
+    for (const worker of workers) {
+        totalSkill += worker.attributes.cognition?.bodilyKinesthetic ?? q(0.50);
+    }
+    const avgSkill = totalSkill / workers.length;
+    // Base time per item (placeholder: 1 hour)
+    const baseTimePerItem_s = 3600;
+    const workshopSpeedFactor = q(1.0); // TODO: get from workshop
+    const effectiveTimePerItem = Math.round(baseTimePerItem_s * SCALE.Q / avgSkill / workshopSpeedFactor);
+    return effectiveTimePerItem * batchSize / SCALE.Q;
+}
+/** Check if production line is complete. */
+export function isProductionLineComplete(line) {
+    return line.itemsProduced >= line.batchSize;
+}
+/** Get progress percentage (0–1). */
+export function getProductionLineProgress(line) {
+    const totalProgress = line.itemsProduced * SCALE.Q + line.progress_Q;
+    const totalRequired = line.batchSize * SCALE.Q;
+    return clampQ(Math.round(totalProgress * SCALE.Q / totalRequired), q(0), SCALE.Q);
+}

package/dist/src/crafting/materials.d.ts

@@ -0,0 +1,53 @@
+import type { Q, I32 } from "../units.js";
+import type { ItemBase } from "../equipment.js";
+/** Physical properties of a material type. */
+export interface MaterialType {
+    id: string;
+    name: string;
+    density_kgPerM3: I32;
+    strength_Q: Q;
+    malleability_Q: Q;
+    conductivity_Q: Q;
+    baseQualityRange: {
+        min_Q: Q;
+        max_Q: Q;
+    };
+}
+/** Material item kind extending ItemBase. */
+export interface Material extends ItemBase {
+    kind: "material";
+    materialTypeId: string;
+    quality_Q: Q;
+    quantity_kg: I32;
+}
+/** Modifier to item stats based on material properties. */
+export interface MaterialPropertyModifier {
+    durabilityMul?: Q;
+    damageMul?: Q;
+    weightMul?: Q;
+    valueMul?: Q;
+}
+export declare const MATERIAL_TYPES: MaterialType[];
+/**
+ * Generate deterministic material quality within a material type's range.
+ * Uses seed to produce consistent quality for given inputs.
+ */
+export declare function deriveMaterialQuality(materialType: MaterialType, seed: number): Q;
+/**
+ * Calculate material effect modifiers for an item based on material properties.
+ * Returns multipliers for various item stats.
+ */
+export declare function calculateMaterialEffect(item: ItemBase, // The base item (weapon, armour, etc.)
+material: Material): MaterialPropertyModifier;
+/**
+ * Extract materials from inventory items that are of kind "material".
+ * Returns map of materialTypeId to total quantity (kg) and average quality.
+ */
+export declare function getAvailableMaterials(inventory: any): Map<string, {
+    totalKg: number;
+    avgQuality_Q: Q;
+}>;
+/** Get material type by ID. */
+export declare function getMaterialTypeById(id: string): MaterialType | undefined;
+/** Create a material item instance. */
+export declare function createMaterialItem(materialTypeId: string, quality_Q: Q, quantity_kg: I32, itemId: string, name?: string): Material;

package/dist/src/crafting/materials.js

@@ -0,0 +1,120 @@
+// src/crafting/materials.ts — Phase 61: Material Catalog
+//
+// Material types with physical properties, and Material item kind.
+// Deterministic quality generation, material property modifiers for crafted items.
+import { SCALE, q, clampQ, mulDiv } from "../units.js";
+import { makeRng } from "../rng.js";
+// ── Material Type Catalogue ───────────────────────────────────────────────────
+export const MATERIAL_TYPES = [
+    {
+        id: "iron",
+        name: "Iron",
+        density_kgPerM3: Math.round(7870 * SCALE.kg),
+        strength_Q: q(0.70),
+        malleability_Q: q(0.40),
+        conductivity_Q: q(0.45),
+        baseQualityRange: { min_Q: q(0.30), max_Q: q(0.80) },
+    },
+    {
+        id: "steel",
+        name: "Steel",
+        density_kgPerM3: Math.round(7850 * SCALE.kg),
+        strength_Q: q(0.90),
+        malleability_Q: q(0.35),
+        conductivity_Q: q(0.40),
+        baseQualityRange: { min_Q: q(0.50), max_Q: q(0.95) },
+    },
+    {
+        id: "wood",
+        name: "Wood",
+        density_kgPerM3: Math.round(600 * SCALE.kg),
+        strength_Q: q(0.30),
+        malleability_Q: q(0.60),
+        conductivity_Q: q(0.10),
+        baseQualityRange: { min_Q: q(0.20), max_Q: q(0.70) },
+    },
+    {
+        id: "leather",
+        name: "Leather",
+        density_kgPerM3: Math.round(860 * SCALE.kg),
+        strength_Q: q(0.25),
+        malleability_Q: q(0.80),
+        conductivity_Q: q(0.15),
+        baseQualityRange: { min_Q: q(0.25), max_Q: q(0.75) },
+    },
+    {
+        id: "bronze",
+        name: "Bronze",
+        density_kgPerM3: Math.round(8800 * SCALE.kg),
+        strength_Q: q(0.65),
+        malleability_Q: q(0.50),
+        conductivity_Q: q(0.55),
+        baseQualityRange: { min_Q: q(0.40), max_Q: q(0.85) },
+    },
+];
+// ── Quality Generation ────────────────────────────────────────────────────────
+/**
+ * Generate deterministic material quality within a material type's range.
+ * Uses seed to produce consistent quality for given inputs.
+ */
+export function deriveMaterialQuality(materialType, seed) {
+    const rng = makeRng(seed, SCALE.Q);
+    const roll = rng.q01();
+    const range = materialType.baseQualityRange.max_Q - materialType.baseQualityRange.min_Q;
+    return clampQ(Math.round(materialType.baseQualityRange.min_Q + mulDiv(range, roll, SCALE.Q)), materialType.baseQualityRange.min_Q, materialType.baseQualityRange.max_Q);
+}
+// ── Material Property Effects ────────────────────────────────────────────────
+/**
+ * Calculate material effect modifiers for an item based on material properties.
+ * Returns multipliers for various item stats.
+ */
+export function calculateMaterialEffect(item, // The base item (weapon, armour, etc.)
+material) {
+    const materialType = MATERIAL_TYPES.find(mt => mt.id === material.materialTypeId);
+    if (!materialType) {
+        return {}; // No effect for unknown material
+    }
+    const qualityFactor = material.quality_Q / SCALE.Q; // 0–1
+    const modifiers = {};
+    // Strength affects durability and damage
+    modifiers.durabilityMul = clampQ(Math.round(q(0.80) + mulDiv(materialType.strength_Q, q(0.40), SCALE.Q)), q(0.50), q(1.50));
+    modifiers.damageMul = clampQ(Math.round(q(0.90) + mulDiv(materialType.strength_Q, q(0.20), SCALE.Q)), q(0.70), q(1.30));
+    // Density affects weight
+    const baseDensity = 1000; // water reference kg/m³
+    const densityFactor = materialType.density_kgPerM3 / (baseDensity * SCALE.kg);
+    modifiers.weightMul = clampQ(Math.round(densityFactor * SCALE.Q), q(0.50), q(2.00));
+    // Quality factor influences value
+    modifiers.valueMul = clampQ(Math.round(q(0.80) + mulDiv(material.quality_Q, q(0.40), SCALE.Q)), q(0.80), q(2.00));
+    return modifiers;
+}
+// ── Inventory Helpers ────────────────────────────────────────────────────────
+/**
+ * Extract materials from inventory items that are of kind "material".
+ * Returns map of materialTypeId to total quantity (kg) and average quality.
+ */
+export function getAvailableMaterials(inventory) {
+    const map = new Map();
+    // TODO: iterate through inventory items, filter by kind === "material"
+    // For each material item, accumulate quantity and weighted quality.
+    return map;
+}
+// ── Utility Functions ────────────────────────────────────────────────────────
+/** Get material type by ID. */
+export function getMaterialTypeById(id) {
+    return MATERIAL_TYPES.find(mt => mt.id === id);
+}
+/** Create a material item instance. */
+export function createMaterialItem(materialTypeId, quality_Q, quantity_kg, itemId, name) {
+    const materialType = getMaterialTypeById(materialTypeId);
+    const displayName = name ?? `${materialType?.name ?? materialTypeId} (${quality_Q})`;
+    return {
+        id: itemId,
+        kind: "material",
+        name: displayName,
+        mass_kg: Math.round(quantity_kg * SCALE.kg), // mass = quantity * density? Actually quantity is already mass.
+        bulk: q(1.0), // placeholder
+        materialTypeId,
+        quality_Q,
+        quantity_kg,
+    };
+}

package/dist/src/crafting/recipes.d.ts

@@ -0,0 +1,75 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+import type { Inventory } from "../inventory.js";
+/** Skill requirement for a recipe. */
+export interface SkillRequirement {
+    skillType: "bodilyKinesthetic" | "logicalMathematical" | "spatial" | "musical";
+    minLevel_Q: Q;
+}
+/** Tool requirement for a recipe. */
+export interface ToolRequirement {
+    toolCategory: "forge" | "precision" | "bladed" | "blunt" | "needlework";
+    minQuality_Q?: Q;
+}
+/** Ingredient requirement for a recipe. */
+export interface Ingredient {
+    itemId: string;
+    quantity: number;
+    materialType?: string;
+    minQuality_Q?: Q;
+}
+/** Recipe definition. */
+export interface Recipe {
+    id: string;
+    name: string;
+    outputItemId: string;
+    outputQuantity: number;
+    skillRequirements: SkillRequirement[];
+    toolRequirements: ToolRequirement[];
+    ingredients: Ingredient[];
+    baseTime_s: number;
+    complexity_Q: Q;
+}
+/** Result of recipe feasibility check. */
+export interface FeasibilityResult {
+    feasible: boolean;
+    missingIngredients: string[];
+    missingSkills: SkillRequirement[];
+    missingTools: ToolRequirement[];
+}
+/** Result of recipe resolution. */
+export interface RecipeResolutionResult {
+    success: boolean;
+    outputItemId: string;
+    outputQuantity: number;
+    quality_Q: Q;
+    timeTaken_s: number;
+    consumedIngredients: {
+        itemId: string;
+        quantity: number;
+    }[];
+    descriptor: "masterwork" | "fine" | "adequate" | "poor" | "ruined";
+}
+export declare const SAMPLE_RECIPES: Recipe[];
+/**
+ * Validate whether a recipe can be crafted given entity skills, inventory, and tools.
+ * Tools are assumed to be available in the workshop; tool quality is checked separately.
+ */
+export declare function validateRecipeFeasibility(recipe: Recipe, inventory: Inventory, entity: Entity, availableToolQualities: Map<string, Q>): FeasibilityResult;
+/**
+ * Calculate crafting cost (time, material consumption) based on recipe, materials, and workshop bonuses.
+ */
+export declare function calculateCraftingCost(recipe: Recipe, materialQualities: Map<string, Q>, // itemId -> quality_Q
+workshopTimeReduction_Q?: Q, workshopQualityBonus_Q?: Q): {
+    time_s: number;
+    materialQualityAvg_Q: Q;
+};
+/**
+ * Resolve a recipe: consume ingredients, produce output with quality based on skills, tools, materials.
+ * Deterministic via seed.
+ */
+export declare function resolveRecipe(recipe: Recipe, entity: Entity, inventory: Inventory, availableToolQualities: Map<string, Q>, worldSeed: number, tick: number, entityId: number, salt: number): RecipeResolutionResult;
+/** Get recipe by ID. */
+export declare function getRecipeById(id: string): Recipe | undefined;
+/** Get all recipes. */
+export declare function getAllRecipes(): Recipe[];

package/dist/src/crafting/recipes.js

@@ -0,0 +1,233 @@
+// src/crafting/recipes.ts — Phase 61: Recipe System
+//
+// Recipe definitions with ingredient requirements, skill checks, and crafting resolution.
+// Deterministic via eventSeed/makeRng, fixed-point arithmetic only.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+import { getItemCountByTemplateId } from "../inventory.js";
+import { makeRng } from "../rng.js";
+import { eventSeed, hashString } from "../sim/seeds.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Default tool quality if not specified. */
+const DEFAULT_TOOL_QUALITY_Q = q(0.60);
+/** Complexity penalty scaling factor. */
+const COMPLEXITY_PENALTY_FACTOR = q(0.30);
+/** Base success chance modifier for complexity. */
+const BASE_SUCCESS_MOD = q(0.80);
+// ── Recipe Catalogue (Example) ────────────────────────────────────────────────
+export const SAMPLE_RECIPES = [
+    {
+        id: "recipe_shortsword",
+        name: "Shortsword",
+        outputItemId: "wpn_knife",
+        outputQuantity: 1,
+        skillRequirements: [
+            { skillType: "bodilyKinesthetic", minLevel_Q: q(0.40) },
+            { skillType: "logicalMathematical", minLevel_Q: q(0.25) },
+        ],
+        toolRequirements: [
+            { toolCategory: "forge", minQuality_Q: q(0.50) },
+            { toolCategory: "bladed", minQuality_Q: q(0.30) },
+        ],
+        ingredients: [
+            { itemId: "material_iron", quantity: 2, materialType: "iron" },
+            { itemId: "material_wood", quantity: 1, materialType: "wood" },
+        ],
+        baseTime_s: 3600, // 1 hour
+        complexity_Q: q(0.60),
+    },
+    {
+        id: "recipe_leather_armour",
+        name: "Leather armour",
+        outputItemId: "arm_leather",
+        outputQuantity: 1,
+        skillRequirements: [
+            { skillType: "bodilyKinesthetic", minLevel_Q: q(0.30) },
+        ],
+        toolRequirements: [
+            { toolCategory: "needlework", minQuality_Q: q(0.20) },
+        ],
+        ingredients: [
+            { itemId: "material_leather", quantity: 5, materialType: "leather" },
+            { itemId: "material_sinew", quantity: 2 },
+        ],
+        baseTime_s: 7200, // 2 hours
+        complexity_Q: q(0.45),
+    },
+];
+// ── Feasibility Checking ──────────────────────────────────────────────────────
+/**
+ * Validate whether a recipe can be crafted given entity skills, inventory, and tools.
+ * Tools are assumed to be available in the workshop; tool quality is checked separately.
+ */
+export function validateRecipeFeasibility(recipe, inventory, entity, availableToolQualities) {
+    const missingIngredients = [];
+    const missingSkills = [];
+    const missingTools = [];
+    // Check ingredients
+    for (const ing of recipe.ingredients) {
+        // Count items with matching templateId (material type ignored for now)
+        const total = getItemCountByTemplateId(inventory, ing.itemId);
+        if (total < ing.quantity) {
+            missingIngredients.push(ing.itemId);
+        }
+    }
+    // Check skills
+    for (const skillReq of recipe.skillRequirements) {
+        const skillQ = getEntitySkill(entity, skillReq.skillType);
+        if (skillQ < skillReq.minLevel_Q) {
+            missingSkills.push(skillReq);
+        }
+    }
+    // Check tools
+    for (const toolReq of recipe.toolRequirements) {
+        const toolQ = availableToolQualities.get(toolReq.toolCategory) ?? q(0);
+        const requiredQ = toolReq.minQuality_Q ?? DEFAULT_TOOL_QUALITY_Q;
+        if (toolQ < requiredQ) {
+            missingTools.push(toolReq);
+        }
+    }
+    return {
+        feasible: missingIngredients.length === 0 && missingSkills.length === 0 && missingTools.length === 0,
+        missingIngredients,
+        missingSkills,
+        missingTools,
+    };
+}
+/** Get entity skill level for a given skill type. */
+function getEntitySkill(entity, skillType) {
+    const cognition = entity.attributes.cognition;
+    if (!cognition)
+        return q(0.50);
+    switch (skillType) {
+        case "bodilyKinesthetic":
+            return (cognition.bodilyKinesthetic ?? q(0.50));
+        case "logicalMathematical":
+            return (cognition.logicalMathematical ?? q(0.50));
+        case "spatial":
+            return (cognition.spatial ?? q(0.50));
+        case "musical":
+            return (cognition.musical ?? q(0.50));
+        default:
+            return q(0.50);
+    }
+}
+// ── Crafting Resolution ───────────────────────────────────────────────────────
+/**
+ * Calculate crafting cost (time, material consumption) based on recipe, materials, and workshop bonuses.
+ */
+export function calculateCraftingCost(recipe, materialQualities, // itemId -> quality_Q
+workshopTimeReduction_Q = q(1.0), workshopQualityBonus_Q = q(0)) {
+    // Average material quality (default q(0.50))
+    let totalQuality = 0;
+    let count = 0;
+    for (const ing of recipe.ingredients) {
+        const qual = materialQualities.get(ing.itemId) ?? q(0.50);
+        totalQuality += qual;
+        count++;
+    }
+    const materialQualityAvg_Q = count > 0 ? Math.round(totalQuality / count) : q(0.50);
+    // Time reduced by workshop efficiency
+    const time_s = Math.round(recipe.baseTime_s * SCALE.Q / workshopTimeReduction_Q);
+    return { time_s, materialQualityAvg_Q };
+}
+/**
+ * Resolve a recipe: consume ingredients, produce output with quality based on skills, tools, materials.
+ * Deterministic via seed.
+ */
+export function resolveRecipe(recipe, entity, inventory, availableToolQualities, worldSeed, tick, entityId, salt) {
+    const seed = eventSeed(worldSeed, tick, entityId, hashString(recipe.id), salt);
+    // Feasibility check (should be done before calling, but we double-check)
+    const feasibility = validateRecipeFeasibility(recipe, inventory, entity, availableToolQualities);
+    if (!feasibility.feasible) {
+        return {
+            success: false,
+            outputItemId: recipe.outputItemId,
+            outputQuantity: 0,
+            quality_Q: q(0),
+            timeTaken_s: recipe.baseTime_s,
+            consumedIngredients: [],
+            descriptor: "ruined",
+        };
+    }
+    // Determine material qualities (for now assume average q(0.50))
+    const materialQualities = new Map();
+    for (const ing of recipe.ingredients) {
+        materialQualities.set(ing.itemId, q(0.50));
+    }
+    // Calculate crafting cost (no workshop bonuses yet)
+    const { time_s, materialQualityAvg_Q } = calculateCraftingCost(recipe, materialQualities);
+    // Compute skill factor: average of required skills weighted by their minimum levels
+    let skillFactor = 0;
+    let totalWeight = 0;
+    for (const skillReq of recipe.skillRequirements) {
+        const skillQ = getEntitySkill(entity, skillReq.skillType);
+        // How much above minimum? Normalized to [0,1]
+        const excess = Math.max(0, skillQ - skillReq.minLevel_Q);
+        const weight = skillReq.minLevel_Q; // higher minimum => more important
+        skillFactor += excess * weight;
+        totalWeight += weight;
+    }
+    const skillBonus = totalWeight > 0 ? skillFactor / totalWeight : q(0);
+    // Compute tool factor: average tool quality relative to requirements
+    let toolFactor = 0;
+    let toolCount = 0;
+    for (const toolReq of recipe.toolRequirements) {
+        const toolQ = availableToolQualities.get(toolReq.toolCategory) ?? q(0);
+        const requiredQ = toolReq.minQuality_Q ?? DEFAULT_TOOL_QUALITY_Q;
+        const excess = Math.max(0, toolQ - requiredQ);
+        toolFactor += excess;
+        toolCount++;
+    }
+    const toolBonus = toolCount > 0 ? toolFactor / toolCount : q(0);
+    // Complexity penalty: higher complexity reduces success chance
+    const complexityPenalty = mulDiv(recipe.complexity_Q, COMPLEXITY_PENALTY_FACTOR, SCALE.Q);
+    // Base success chance = skillBonus + toolBonus - complexityPenalty + BASE_SUCCESS_MOD
+    const rawSuccess = skillBonus + toolBonus - complexityPenalty + BASE_SUCCESS_MOD;
+    const successChance = clampQ(rawSuccess, q(0), SCALE.Q);
+    // Deterministic roll
+    const rng = makeRng(seed, SCALE.Q);
+    const roll = rng.q01();
+    const success = roll < successChance;
+    // Quality calculation: material quality × skill factor × tool factor ± variance
+    const expectedQuality = qMul(materialQualityAvg_Q, qMul(skillBonus, toolBonus));
+    const variance = mulDiv(rng.q01() - SCALE.Q / 2, q(0.20), SCALE.Q); // ±20%
+    const quality_Q = clampQ((expectedQuality + variance), q(0), SCALE.Q);
+    // Time taken (inverse of skill factor)
+    const timeTaken_s = Math.round(time_s * q(0.50) / (skillBonus > 0 ? skillBonus : q(0.50)));
+    // Determine descriptor
+    const descriptor = qualityToDescriptor(quality_Q);
+    // Consume ingredients (placeholder)
+    const consumedIngredients = recipe.ingredients.map(ing => ({
+        itemId: ing.itemId,
+        quantity: ing.quantity,
+    }));
+    return {
+        success,
+        outputItemId: recipe.outputItemId,
+        outputQuantity: success ? recipe.outputQuantity : 0,
+        quality_Q,
+        timeTaken_s,
+        consumedIngredients,
+        descriptor,
+    };
+}
+function qualityToDescriptor(quality_Q) {
+    if (quality_Q >= q(0.85))
+        return "masterwork";
+    if (quality_Q >= q(0.65))
+        return "fine";
+    if (quality_Q >= q(0.40))
+        return "adequate";
+    if (quality_Q >= q(0.20))
+        return "poor";
+    return "ruined";
+}
+// ── Utility Functions ─────────────────────────────────────────────────────────
+/** Get recipe by ID. */
+export function getRecipeById(id) {
+    return SAMPLE_RECIPES.find(r => r.id === id);
+}
+/** Get all recipes. */
+export function getAllRecipes() {
+    return SAMPLE_RECIPES;
+}