@its-not-rocket-science/ananke 0.1.0

package/dist/src/competence/teaching.js

@@ -0,0 +1,121 @@
+// src/competence/teaching.ts — Phase 37: Teaching and Skill Transfer
+//
+// Interpersonal intelligence governs social reading and teaching effectiveness.
+// Extends Phase 21 progression system with interpersonal-based skill transfer.
+//
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ, qMul, mulDiv } from "../units.js";
+import { getSkill } from "../sim/skills.js";
+import { makeRng } from "../rng.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Base XP per hour of quality teaching. */
+const BASE_XP_RATE = 10; // 10 XP per hour at full quality
+/** Base fatigue cost per hour of teaching. */
+const BASE_FATIGUE_PER_HOUR = 500; // 500 J per hour
+/** Maximum XP gain per session. */
+const MAX_XP_PER_SESSION = 100;
+/** Fatigue multiplier for extended sessions. */
+const FATIGUE_MULTIPLIER = 1.5;
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Resolve a teaching session and compute XP gain.
+ *
+ * Formula:
+ *   xpGained = hours × BASE_XP_RATE × interpersonal(teacher) × learningRate(learner)
+ *   teacherFatigueJ = hours × BASE_FATIGUE_PER_HOUR × FATIGUE_MULTIPLIER
+ *
+ * @param teacher - The entity providing instruction.
+ * @param learner - The entity receiving instruction.
+ * @param spec - Teaching specification.
+ * @returns Teaching outcome with XP gained and teacher fatigue.
+ */
+export function resolveTeaching(teacher, learner, spec) {
+    // Get interpersonal skill (teacher's ability to convey knowledge)
+    const interpersonal = spec.teacherInterpersonal_Q
+        ?? (teacher.attributes.cognition?.interpersonal ?? q(0.50));
+    // Learning rate based on learner's interpersonal (receptivity) and natural aptitude
+    // Phase 37: interpersonal affects both teaching AND learning
+    const learnerInterpersonal = spec.learnerLearningRate_Q
+        ?? (learner.attributes.cognition?.interpersonal ?? q(0.50));
+    // Teaching quality: teacher's interpersonal skill
+    const teachingQuality_Q = clampQ(interpersonal, q(0.20), SCALE.Q);
+    // Learning rate: learner's interpersonal (social learning) + existing skill level
+    const existingSkill = getSkill(learner.skills, spec.domain);
+    const skillLevelBonus = clampQ(mulDiv(existingSkill.energyTransferMul, q(0.30), SCALE.Q), q(0), q(0.30));
+    const learningRate_Q = clampQ((qMul(learnerInterpersonal, q(0.70)) + skillLevelBonus), q(0.20), SCALE.Q);
+    // Calculate XP: hours × base rate × teaching quality × learning rate
+    const rawXp = spec.hours * BASE_XP_RATE;
+    const qualityMul = mulDiv(teachingQuality_Q, learningRate_Q, SCALE.Q);
+    const xpGained = Math.min(MAX_XP_PER_SESSION, Math.round(rawXp * qualityMul / SCALE.Q));
+    // Teacher fatigue scales with hours and effort (inversely with skill)
+    // Better teachers expend less energy for same result
+    const effortMul = clampQ((SCALE.Q - mulDiv(interpersonal, q(0.50), SCALE.Q)), q(0.50), SCALE.Q);
+    const baseFatigue = spec.hours * BASE_FATIGUE_PER_HOUR;
+    const teacherFatigueJ = Math.round(baseFatigue * FATIGUE_MULTIPLIER * effortMul / SCALE.Q);
+    return { xpGained, teacherFatigueJ, teachingQuality_Q };
+}
+/**
+ * Compute maximum effective teaching hours based on teacher stamina.
+ */
+export function computeMaxTeachingHours(teacher, availableEnergyJ) {
+    const interpersonal = (teacher.attributes.cognition?.interpersonal ?? q(0.50));
+    // More skilled teachers use energy more efficiently
+    const effortMul = clampQ((SCALE.Q - mulDiv(interpersonal, q(0.50), SCALE.Q)), q(0.50), SCALE.Q);
+    const fatiguePerHour = BASE_FATIGUE_PER_HOUR * FATIGUE_MULTIPLIER * effortMul / SCALE.Q;
+    return Math.floor(availableEnergyJ / Math.max(1, fatiguePerHour));
+}
+/**
+ * Check if teacher is qualified to teach a skill.
+ * Teacher should have at least journeyman level (skill delta showing improvement).
+ */
+export function isQualifiedTeacher(teacher, domain, minimumProficiency = q(0.30)) {
+    const skill = getSkill(teacher.skills, domain);
+    // Check if teacher has made meaningful progress in this skill
+    // Negative energyTransferMul means they've learned (more efficient)
+    // A good teacher should have negative energyTransferMul (below baseline)
+    // proficiency = 1.0 + (energyTransferMul / SCALE.Q), where negative mul = better
+    const proficiency = clampQ((SCALE.Q + skill.energyTransferMul), q(0), SCALE.Q);
+    // Default skill has energyTransferMul = 0, so proficiency = SCALE.Q (1.0)
+    // We need to check if they've actually improved (negative mul)
+    const hasActualSkill = skill.energyTransferMul < 0;
+    return hasActualSkill && proficiency >= minimumProficiency;
+}
+// ── Deception detection (Phase 37 extension) ──────────────────────────────────
+/**
+ * Compute probability of detecting deception.
+ *
+ * Formula:
+ *   P_detect = clamp(
+ *     attentionDepth × 0.50 + interpersonal × 0.50 − plausibility,
+ *     0, 1)
+ *
+ * @param detector - The entity attempting to detect deception.
+ * @param plausibility_Q - Plausibility of the deception (0–1).
+ * @returns Detection probability (0–1).
+ */
+export function computeDeceptionDetectionProbability(detector, plausibility_Q) {
+    // Attention depth contribution (perception skill)
+    const attentionDepth = detector.attributes.perception?.attentionDepth ?? 4;
+    const attentionContrib = clampQ(Math.trunc((attentionDepth * SCALE.Q) / 10), q(0), SCALE.Q);
+    // Interpersonal contribution (social intuition)
+    const interpersonal = (detector.attributes.cognition?.interpersonal ?? q(0.50));
+    // Combined detection capability: 50% attention + 50% interpersonal
+    const detectionCap = clampQ((mulDiv(attentionContrib, q(0.50), SCALE.Q) +
+        mulDiv(interpersonal, q(0.50), SCALE.Q)), q(0), SCALE.Q);
+    // Subtract plausibility (better lies are harder to detect)
+    const pDetect = clampQ((detectionCap - plausibility_Q), q(0), SCALE.Q);
+    return pDetect;
+}
+/**
+ * Resolve deception detection.
+ * @returns True if deception was detected.
+ */
+export function resolveDeceptionDetection(detector, plausibility_Q, seed) {
+    const pDetect = computeDeceptionDetectionProbability(detector, plausibility_Q);
+    const rng = makeRng(seed, SCALE.Q);
+    const roll = rng.q01();
+    const detected = roll < pDetect;
+    // Confidence based on detection probability (higher = more certain)
+    const confidence_Q = clampQ((pDetect + mulDiv(rng.q01(), q(0.20), SCALE.Q)), q(0.50), SCALE.Q);
+    return { detected, confidence_Q };
+}

package/dist/src/competence/willpower.d.ts

@@ -0,0 +1,74 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+/**
+ * Willpower state analogous to physical energy reserve.
+ */
+export interface WillpowerState {
+    /** Current willpower in joules (same unit as energy_J). */
+    current_J: number;
+    /** Maximum willpower capacity based on intrapersonal intelligence. */
+    max_J: number;
+}
+/**
+ * Outcome of a willpower operation.
+ */
+export interface WillpowerOutcome {
+    /** True if operation succeeded (sufficient willpower). */
+    success: boolean;
+    /** Remaining willpower after operation. */
+    remaining_J: number;
+    /** True if willpower was depleted by this operation. */
+    depleted: boolean;
+}
+/**
+ * Compute maximum willpower for an entity based on intrapersonal intelligence.
+ *
+ * Formula: max_J = intrapersonal × SCALE_WILLPOWER_J
+ *
+ * @param entity - The entity to compute willpower for.
+ * @returns Maximum willpower capacity in joules.
+ */
+export declare function computeMaxWillpower(entity: Entity): number;
+/**
+ * Initialize willpower state for an entity.
+ * Call this when first adding willpower to an entity.
+ */
+export declare function initializeWillpower(entity: Entity): WillpowerState;
+/**
+ * Deduct willpower for a cognitive operation.
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @param cost_J - Cost of the operation in joules.
+ * @returns Outcome indicating success/failure and depletion status.
+ */
+export declare function deductWillpower(willpower: WillpowerState, cost_J: number): WillpowerOutcome;
+/**
+ * Replenish willpower during rest.
+ *
+ * Formula: replenish = max_J × REPLENISH_RATE_PER_HOUR × hours
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @param hours - Hours of rest.
+ * @returns Amount actually replenished.
+ */
+export declare function replenishWillpower(willpower: WillpowerState, hours: number): number;
+/**
+ * Step willpower for concentration aura (Phase 12B integration).
+ * Called per tick when entity has active concentration.
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @returns True if concentration can be maintained.
+ */
+export declare function stepConcentrationWillpower(willpower: WillpowerState): boolean;
+/**
+ * Check if entity has sufficient willpower for an operation.
+ */
+export declare function hasSufficientWillpower(willpower: WillpowerState, cost_J: number): boolean;
+/**
+ * Get willpower ratio (0–1) for UI/AI decisions.
+ */
+export declare function getWillpowerRatio(willpower: WillpowerState): Q;
+/**
+ * Force willpower state update (for downtime healing, cheats, etc).
+ */
+export declare function setWillpower(willpower: WillpowerState, value_J: number): void;

package/dist/src/competence/willpower.js

@@ -0,0 +1,114 @@
+// src/competence/willpower.ts — Phase 38: Willpower Reserve (Intrapersonal Intelligence)
+//
+// Intrapersonal intelligence governs internal management: willpower, sustained focus,
+// emotional self-regulation, and mental stamina for cognitively demanding tasks.
+//
+// Analogous to Phase 2B's reserveEnergy_J for physical stamina.
+// No kernel import — pure resolution module.
+import { SCALE, q, clampQ } from "../units.js";
+// ── Constants ─────────────────────────────────────────────────────────────────
+/** Scale factor: max willpower = intrapersonal × SCALE_WILLPOWER_J. */
+const SCALE_WILLPOWER_J = 50_000; // 50kJ max at intrapersonal q(1.0)
+/** Base replenishment rate: q(0.10) of max per hour of rest. */
+const REPLENISH_RATE_PER_HOUR = q(0.10);
+/** Concentration aura drain per tick (from Phase 12B). */
+const CONCENTRATION_DRAIN_PER_TICK = 100; // 100 J per tick
+/** Minimum willpower required to maintain concentration. */
+const MIN_WILLPOWER_FOR_CONCENTRATION = 50;
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Compute maximum willpower for an entity based on intrapersonal intelligence.
+ *
+ * Formula: max_J = intrapersonal × SCALE_WILLPOWER_J
+ *
+ * @param entity - The entity to compute willpower for.
+ * @returns Maximum willpower capacity in joules.
+ */
+export function computeMaxWillpower(entity) {
+    const intrapersonal = (entity.attributes.cognition?.intrapersonal ?? q(0.55));
+    return Math.round((intrapersonal * SCALE_WILLPOWER_J) / SCALE.Q);
+}
+/**
+ * Initialize willpower state for an entity.
+ * Call this when first adding willpower to an entity.
+ */
+export function initializeWillpower(entity) {
+    const max_J = computeMaxWillpower(entity);
+    return {
+        current_J: max_J, // Start at full
+        max_J,
+    };
+}
+/**
+ * Deduct willpower for a cognitive operation.
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @param cost_J - Cost of the operation in joules.
+ * @returns Outcome indicating success/failure and depletion status.
+ */
+export function deductWillpower(willpower, cost_J) {
+    if (willpower.current_J < cost_J) {
+        // Insufficient willpower - operation fails
+        return {
+            success: false,
+            remaining_J: willpower.current_J,
+            depleted: willpower.current_J < MIN_WILLPOWER_FOR_CONCENTRATION,
+        };
+    }
+    willpower.current_J -= cost_J;
+    const depleted = willpower.current_J < MIN_WILLPOWER_FOR_CONCENTRATION;
+    return {
+        success: true,
+        remaining_J: willpower.current_J,
+        depleted,
+    };
+}
+/**
+ * Replenish willpower during rest.
+ *
+ * Formula: replenish = max_J × REPLENISH_RATE_PER_HOUR × hours
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @param hours - Hours of rest.
+ * @returns Amount actually replenished.
+ */
+export function replenishWillpower(willpower, hours) {
+    const replenishAmount = Math.round((willpower.max_J * REPLENISH_RATE_PER_HOUR * hours) / SCALE.Q);
+    const before = willpower.current_J;
+    willpower.current_J = Math.min(willpower.max_J, willpower.current_J + replenishAmount);
+    return willpower.current_J - before;
+}
+/**
+ * Step willpower for concentration aura (Phase 12B integration).
+ * Called per tick when entity has active concentration.
+ *
+ * @param willpower - Current willpower state (mutated).
+ * @returns True if concentration can be maintained.
+ */
+export function stepConcentrationWillpower(willpower) {
+    if (willpower.current_J < CONCENTRATION_DRAIN_PER_TICK) {
+        // Insufficient willpower - aura collapses
+        willpower.current_J = Math.max(0, willpower.current_J);
+        return false;
+    }
+    willpower.current_J -= CONCENTRATION_DRAIN_PER_TICK;
+    return willpower.current_J >= MIN_WILLPOWER_FOR_CONCENTRATION;
+}
+/**
+ * Check if entity has sufficient willpower for an operation.
+ */
+export function hasSufficientWillpower(willpower, cost_J) {
+    return willpower.current_J >= cost_J;
+}
+/**
+ * Get willpower ratio (0–1) for UI/AI decisions.
+ */
+export function getWillpowerRatio(willpower) {
+    return clampQ(Math.round((willpower.current_J * SCALE.Q) / Math.max(1, willpower.max_J)), q(0), SCALE.Q);
+}
+/**
+ * Force willpower state update (for downtime healing, cheats, etc).
+ */
+export function setWillpower(willpower, value_J) {
+    willpower.current_J = clampQ(value_J, 0, willpower.max_J);
+}

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

@@ -0,0 +1,55 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+import type { Inventory } from "../inventory.js";
+import type { Recipe } from "./recipes.js";
+import type { Material } from "./materials.js";
+import type { WorkshopInstance } from "./workshops.js";
+import type { ProductionLine } from "./manufacturing.js";
+import { getRecipeById, getAllRecipes, type FeasibilityResult, type RecipeResolutionResult } from "./recipes.js";
+import { getMaterialTypeById, createMaterialItem, type MaterialPropertyModifier } from "./materials.js";
+import { getWorkshopBonus, validateWorkshopRequirements, createWorkshop, upgradeWorkshop, type WorkshopBonus } from "./workshops.js";
+import { estimateBatchCompletionTime, isProductionLineComplete } from "./manufacturing.js";
+/**
+ * Craft a single item using a recipe, entity, inventory, and workshop.
+ * Returns resolution result with success, quality, time, and consumed ingredients.
+ */
+export declare function craftItem(recipeId: string, entity: Entity, inventory: Inventory, workshop: WorkshopInstance, worldSeed: number, tick: number, salt: number): RecipeResolutionResult;
+/**
+ * Start batch manufacturing of items.
+ * Creates a production line and returns its ID.
+ */
+export declare function startManufacturing(recipeId: string, quantity: number, workshop: WorkshopInstance, workers: Entity[], worldSeed: number, tick: number, salt: number): {
+    success: boolean;
+    lineId?: string;
+    error?: string;
+};
+/**
+ * Advance manufacturing for a production line.
+ * Returns items completed in this step.
+ */
+export declare function advanceManufacturing(lineId: string, deltaTime_s: number, workers: Entity[], workshop: WorkshopInstance, worldSeed: number, tick: number, salt: number): {
+    itemsCompleted: number;
+    totalProduced: number;
+    progress_Q: Q;
+};
+/**
+ * Get all recipes that can be crafted by an entity with given inventory and workshop.
+ * Returns filtered list of recipes.
+ */
+export declare function getAvailableRecipes(entity: Entity, inventory: Inventory, workshop: WorkshopInstance): Recipe[];
+/**
+ * Get material properties for a crafted item.
+ * Applies material property modifiers to base item stats.
+ */
+export declare function applyMaterialProperties(baseItem: any, // Placeholder: Item type
+material: Material): MaterialPropertyModifier;
+/**
+ * Integrate crafting result into inventory.
+ * Consumes ingredients and adds crafted item.
+ * Returns success and error if any.
+ */
+export declare function integrateCraftingIntoInventory(inventory: Inventory, result: RecipeResolutionResult, instanceId: string): {
+    success: boolean;
+    error?: string;
+};
+export { type Recipe, type FeasibilityResult, type RecipeResolutionResult, type Material, type MaterialPropertyModifier, type WorkshopInstance, type WorkshopBonus, type ProductionLine, getRecipeById, getAllRecipes, getMaterialTypeById, createMaterialItem, getWorkshopBonus, validateWorkshopRequirements, createWorkshop, upgradeWorkshop, estimateBatchCompletionTime, isProductionLineComplete, };

package/dist/src/crafting/index.js

@@ -0,0 +1,229 @@
+// src/crafting/index.ts — Phase 61: Crafting Ecosystem Main API
+//
+// Integration layer for crafting, materials, workshops, and manufacturing.
+// Provides high‑level functions for game systems to interact with crafting.
+import { q, SCALE, qMul } from "../units.js";
+import { eventSeed, hashString } from "../sim/seeds.js";
+import { consumeItemsByTemplateId, addItemToInventory } from "../inventory.js";
+import { validateRecipeFeasibility, resolveRecipe, getRecipeById, getAllRecipes, } from "./recipes.js";
+import { getMaterialTypeById, calculateMaterialEffect, createMaterialItem, } from "./materials.js";
+import { getWorkshopBonus, validateWorkshopRequirements, createWorkshop, upgradeWorkshop, } from "./workshops.js";
+import { setupProductionLine, advanceProduction, estimateBatchCompletionTime, isProductionLineComplete, } from "./manufacturing.js";
+// ── Main Crafting API ─────────────────────────────────────────────────────────
+/**
+ * Craft a single item using a recipe, entity, inventory, and workshop.
+ * Returns resolution result with success, quality, time, and consumed ingredients.
+ */
+export function craftItem(recipeId, entity, inventory, workshop, worldSeed, tick, salt) {
+    const recipe = getRecipeById(recipeId);
+    if (!recipe) {
+        return {
+            success: false,
+            outputItemId: recipeId,
+            outputQuantity: 0,
+            quality_Q: q(0),
+            timeTaken_s: 0,
+            consumedIngredients: [],
+            descriptor: "ruined",
+        };
+    }
+    // Convert workshop tools map to format expected by recipes
+    const toolQualities = new Map();
+    for (const [category, quality] of workshop.availableTools.entries()) {
+        toolQualities.set(category, quality);
+    }
+    // Validate feasibility
+    const feasibility = validateRecipeFeasibility(recipe, inventory, entity, toolQualities);
+    if (!feasibility.feasible) {
+        return {
+            success: false,
+            outputItemId: recipe.outputItemId,
+            outputQuantity: 0,
+            quality_Q: q(0),
+            timeTaken_s: recipe.baseTime_s,
+            consumedIngredients: [],
+            descriptor: "ruined",
+        };
+    }
+    // Apply workshop bonuses
+    const workshopBonus = getWorkshopBonus(workshop, recipe);
+    // Resolve recipe (workshop bonuses not yet integrated into resolveRecipe)
+    const result = resolveRecipe(recipe, entity, inventory, toolQualities, worldSeed, tick, entity.id, salt);
+    // Adjust time with workshop time reduction
+    result.timeTaken_s = Math.round(result.timeTaken_s * SCALE.Q / workshopBonus.timeReduction_Q);
+    // Adjust quality with workshop quality bonus
+    result.quality_Q = clampQ(qMul(result.quality_Q, workshopBonus.qualityBonus_Q), q(0), SCALE.Q);
+    // Update descriptor based on new quality
+    result.descriptor = qualityToDescriptor(result.quality_Q);
+    // If crafting succeeded, integrate into inventory
+    if (result.success) {
+        const instanceSeed = eventSeed(worldSeed, tick, entity.id, hashString(recipe.id), salt + 0xCAFE);
+        const instanceId = `craft_${recipeId}_${instanceSeed}`;
+        const integration = integrateCraftingIntoInventory(inventory, result, instanceId);
+        if (!integration.success) {
+            return {
+                success: false,
+                outputItemId: recipe.outputItemId,
+                outputQuantity: 0,
+                quality_Q: q(0),
+                timeTaken_s: result.timeTaken_s,
+                consumedIngredients: [],
+                descriptor: "ruined",
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Start batch manufacturing of items.
+ * Creates a production line and returns its ID.
+ */
+export function startManufacturing(recipeId, quantity, workshop, workers, worldSeed, tick, salt) {
+    const recipe = getRecipeById(recipeId);
+    if (!recipe) {
+        return { success: false, error: `Recipe ${recipeId} not found` };
+    }
+    // Validate workshop requirements
+    const workshopReq = validateWorkshopRequirements(workshop, recipe);
+    if (workshopReq.facilityLevelInsufficient || workshopReq.missingTools.length > 0) {
+        return { success: false, error: "Workshop insufficient for recipe" };
+    }
+    // Validate worker skills (at least one worker meets skill requirements)
+    let skilledWorkerExists = false;
+    for (const worker of workers) {
+        let meetsAll = true;
+        for (const skillReq of recipe.skillRequirements) {
+            const skill = worker.attributes.cognition?.[skillReq.skillType] ?? q(0);
+            if (skill < skillReq.minLevel_Q) {
+                meetsAll = false;
+                break;
+            }
+        }
+        if (meetsAll) {
+            skilledWorkerExists = true;
+            break;
+        }
+    }
+    if (!skilledWorkerExists) {
+        return { success: false, error: "No worker meets skill requirements" };
+    }
+    const primaryWorkerId = workers.length > 0 ? workers[0].id : 0;
+    const lineSeed = eventSeed(worldSeed, tick, primaryWorkerId, hashString(recipe.id), salt);
+    const orderId = `order_${worldSeed}_${tick}_${recipe.id}_${salt}`;
+    // Create manufacturing order
+    const order = {
+        orderId,
+        recipeId,
+        quantity,
+        workshop,
+    };
+    // Setup production line
+    const line = setupProductionLine(order, workers, lineSeed);
+    // TODO: store production line in persistent state
+    return { success: true, lineId: line.lineId };
+}
+/**
+ * Advance manufacturing for a production line.
+ * Returns items completed in this step.
+ */
+export function advanceManufacturing(lineId, deltaTime_s, workers, workshop, worldSeed, tick, salt) {
+    // Compute deterministic seed from lineId
+    let lineIdHash = 0;
+    for (let i = 0; i < lineId.length; i++)
+        lineIdHash += lineId.charCodeAt(i);
+    const seed = eventSeed(worldSeed, tick, lineIdHash, 0, salt);
+    // TODO: retrieve production line by lineId
+    const line = {
+        lineId,
+        recipeId: "recipe_shortsword",
+        batchSize: 10,
+        itemsProduced: 0,
+        progress_Q: q(0),
+        assignedWorkers: workers.map(w => w.id),
+        priority: 1,
+        qualityRange: { min_Q: q(0.30), max_Q: q(0.90), avg_Q: q(0.60) },
+    };
+    const result = advanceProduction(line, deltaTime_s, workers, workshop, seed);
+    // TODO: update stored line
+    return {
+        itemsCompleted: result.itemsCompleted,
+        totalProduced: result.totalItemsProduced,
+        progress_Q: result.progress_Q,
+    };
+}
+// ── Query API ─────────────────────────────────────────────────────────────────
+/**
+ * Get all recipes that can be crafted by an entity with given inventory and workshop.
+ * Returns filtered list of recipes.
+ */
+export function getAvailableRecipes(entity, inventory, workshop) {
+    const allRecipes = getAllRecipes();
+    const toolQualities = new Map();
+    for (const [category, quality] of workshop.availableTools.entries()) {
+        toolQualities.set(category, quality);
+    }
+    return allRecipes.filter(recipe => {
+        const feasibility = validateRecipeFeasibility(recipe, inventory, entity, toolQualities);
+        return feasibility.feasible;
+    });
+}
+/**
+ * Get material properties for a crafted item.
+ * Applies material property modifiers to base item stats.
+ */
+export function applyMaterialProperties(baseItem, // Placeholder: Item type
+material) {
+    return calculateMaterialEffect(baseItem, material);
+}
+// ── Integration with Existing Systems ─────────────────────────────────────────
+/**
+ * Integrate crafting result into inventory.
+ * Consumes ingredients and adds crafted item.
+ * Returns success and error if any.
+ */
+export function integrateCraftingIntoInventory(inventory, result, instanceId) {
+    if (!result.success) {
+        return { success: false, error: "Crafting failed" };
+    }
+    // Consume ingredients
+    for (const ing of result.consumedIngredients) {
+        const ok = consumeItemsByTemplateId(inventory, ing.itemId, ing.quantity);
+        if (!ok) {
+            return { success: false, error: `Insufficient ${ing.itemId} after validation` };
+        }
+    }
+    // Create item instance
+    const itemInstance = {
+        instanceId,
+        templateId: result.outputItemId,
+        quantity: result.outputQuantity,
+        durability_Q: result.quality_Q, // Use quality as durability placeholder
+        modifications: [],
+        containerPath: [],
+    };
+    // Add to inventory
+    const addResult = addItemToInventory(inventory, itemInstance);
+    if (!addResult.success) {
+        return { success: false, error: "No container capacity for crafted item" };
+    }
+    return { success: true };
+}
+// ── Utility Functions ─────────────────────────────────────────────────────────
+function clampQ(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+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";
+}
+// ── Exports ───────────────────────────────────────────────────────────────────
+export { 
+// Functions
+getRecipeById, getAllRecipes, getMaterialTypeById, createMaterialItem, getWorkshopBonus, validateWorkshopRequirements, createWorkshop, upgradeWorkshop, estimateBatchCompletionTime, isProductionLineComplete, };

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

@@ -0,0 +1,83 @@
+import type { Q } from "../units.js";
+import type { Entity } from "../sim/entity.js";
+import type { Recipe } from "./recipes.js";
+import type { WorkshopInstance } from "./workshops.js";
+/** Production line state for batch manufacturing. */
+export interface ProductionLine {
+    lineId: string;
+    recipeId: string;
+    batchSize: number;
+    itemsProduced: number;
+    progress_Q: Q;
+    assignedWorkers: number[];
+    priority: number;
+    qualityRange: {
+        min_Q: Q;
+        max_Q: Q;
+        avg_Q: Q;
+    };
+}
+/** Manufacturing order for starting batch production. */
+export interface ManufacturingOrder {
+    orderId: string;
+    recipeId: string;
+    quantity: number;
+    workshop: WorkshopInstance;
+    deadlineTick?: number;
+}
+/** Result of advancing production. */
+export interface ProductionAdvanceResult {
+    itemsCompleted: number;
+    totalItemsProduced: number;
+    progress_Q: Q;
+    qualityRange: {
+        min_Q: Q;
+        max_Q: Q;
+        avg_Q: Q;
+    };
+}
+/** Assembly step for multi-stage crafting. */
+export interface AssemblyStep {
+    stepId: string;
+    description: string;
+    requiredSkill: string;
+    timeFraction: Q;
+    toolRequirements: string[];
+}
+/**
+ * Initialize a production line for batch manufacturing.
+ */
+export declare function setupProductionLine(order: ManufacturingOrder, workers: Entity[], seed: number): ProductionLine;
+/**
+ * Advance production line by deltaTime seconds.
+ * Progress accumulates based on number of workers and their skills.
+ * Returns new items completed and updated progress.
+ */
+export declare function advanceProduction(productionLine: ProductionLine, deltaTime_s: number, workers: Entity[], // Must match assignedWorkers IDs
+workshop: WorkshopInstance, seed: number): ProductionAdvanceResult;
+/**
+ * Calculate predicted quality range for a batch based on workers, materials, workshop.
+ * Returns min, max, and average expected quality.
+ */
+export declare function calculateBatchQualityRange(workers: Entity[], workshop: WorkshopInstance, seed: number): {
+    min_Q: Q;
+    max_Q: Q;
+    avg_Q: Q;
+};
+/**
+ * Create assembly steps for a complex recipe.
+ */
+export declare function createAssemblySteps(recipe: Recipe): AssemblyStep[];
+/**
+ * Advance a single assembly step.
+ */
+export declare function advanceAssemblyStep(step: AssemblyStep, worker: Entity, deltaTime_s: number, availableTools: Map<string, Q>): {
+    progress_Q: Q;
+    completed: boolean;
+};
+/** Estimate time to complete a batch given workers and workshop. */
+export declare function estimateBatchCompletionTime(batchSize: number, workers: Entity[], workshop: WorkshopInstance): number;
+/** Check if production line is complete. */
+export declare function isProductionLineComplete(line: ProductionLine): boolean;
+/** Get progress percentage (0–1). */
+export declare function getProductionLineProgress(line: ProductionLine): Q;