equilibria-mcp-server 1.0.0

package/dist/templates/consumer.js

@@ -0,0 +1,1978 @@
+/**
+ * Consumer Theory Templates
+ *
+ * Templates for consumer theory models including budget constraints,
+ * indifference curves, and optimal choice analysis.
+ *
+ * Phase 3.1: Budget Constraints
+ * Phase 3.2: Preferences (indifference curves, optimal choice)
+ */
+// ============================================================================
+// PHASE 3.1: BUDGET CONSTRAINTS
+// ============================================================================
+/**
+ * Basic Budget Constraint
+ *
+ * Two-good budget line showing the trade-off between goods X and Y
+ * given income (M) and prices (Px, Py).
+ *
+ * Budget constraint: Px * X + Py * Y = M
+ * Rearranged: Y = M/Py - (Px/Py) * X
+ */
+const budgetConstraintBasic = {
+    id: 'budget_constraint_basic',
+    name: 'Basic Budget Constraint',
+    description: 'Two-good budget line showing the affordable combinations of goods X and Y given income and prices. The slope represents the relative price ratio.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['budget constraint', 'consumer theory', 'affordability', 'price ratio'],
+    parameters: {
+        income: {
+            type: 'number',
+            default: 100,
+            min: 10,
+            max: 500,
+            description: 'Consumer income (M)',
+        },
+        priceX: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 50,
+            description: 'Price of good X (Px)',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            min: 1,
+            max: 50,
+            description: 'Price of good Y (Py)',
+        },
+    },
+    generate: (params) => {
+        const M = params.income ?? 100;
+        const Px = params.priceX ?? 10;
+        const Py = params.priceY ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Budget Constraint',
+                description: 'Two-good budget constraint showing affordable combinations',
+            },
+            parameters: {
+                M: { value: M, label: 'Income', min: 10, max: 500, step: 10 },
+                Px: { value: Px, label: 'Price of X', min: 1, max: 50, step: 1 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 50, step: 1 },
+                // Intercepts
+                maxX: { expression: 'M / Px', label: 'Max X', readonly: true },
+                maxY: { expression: 'M / Py', label: 'Max Y', readonly: true },
+                // Slope (opportunity cost of X in terms of Y)
+                slope: { expression: '-Px / Py', label: 'Slope (-Px/Py)', readonly: true },
+                // Example affordable bundle
+                bundleX: { value: M / (2 * Px), label: 'Bundle X', min: 0, max: 'maxX' },
+                bundleY: {
+                    expression: '(M - Px * bundleX) / Py',
+                    label: 'Bundle Y',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Budget Constraint: Px·X + Py·Y = M',
+                    xAxis: { label: 'Good X', min: 0, max: 'maxX * 1.2' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'maxY * 1.2' },
+                    elements: [
+                        // Affordable region
+                        {
+                            id: 'affordable-region',
+                            type: 'area',
+                            topBoundary: 'budget-line',
+                            bottomBoundary: '0',
+                            leftBoundary: '0',
+                            rightBoundary: 'maxX',
+                            color: '#22C55E',
+                            opacity: 0.2,
+                            label: 'Affordable Region',
+                        },
+                        // Budget line
+                        {
+                            id: 'budget-line',
+                            type: 'line',
+                            equation: 'M / Py - (Px / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Budget Line',
+                            domain: { min: 0, max: 'maxX' },
+                        },
+                        // X-intercept
+                        {
+                            id: 'x-intercept',
+                            type: 'point',
+                            x: 'maxX',
+                            y: 0,
+                            color: '#7C3AED',
+                            label: 'M/Px',
+                        },
+                        // Y-intercept
+                        {
+                            id: 'y-intercept',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY',
+                            color: '#7C3AED',
+                            label: 'M/Py',
+                        },
+                        // Current bundle
+                        {
+                            id: 'bundle',
+                            type: 'point',
+                            x: 'bundleX',
+                            y: 'bundleY',
+                            color: '#16A34A',
+                            label: 'Bundle',
+                            droplines: { x: true, y: true },
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { bundleX: 'x' } },
+                                constraints: { bounds: { minX: 0, maxX: 'maxX' } },
+                            },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'slope-label',
+                            text: 'Slope = -Px/Py = ${slope:.2f}',
+                            x: 'maxX * 0.5',
+                            y: 'maxY * 0.7',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'bundle-label',
+                            text: '(${bundleX:.1f}, ${bundleY:.1f})',
+                            x: 'bundleX + maxX * 0.05',
+                            y: 'bundleY + maxY * 0.05',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Budget Constraint with Income Change
+ *
+ * Shows how the budget constraint shifts when income changes,
+ * demonstrating parallel shifts in the budget line.
+ */
+const budgetConstraintIncomeChange = {
+    id: 'budget_constraint_income_change',
+    name: 'Budget Constraint - Income Change',
+    description: 'Demonstrates how budget constraint shifts with income changes. Increase in income causes parallel outward shift; decrease causes inward shift.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['budget constraint', 'income effect', 'parallel shift', 'consumer theory'],
+    parameters: {
+        initialIncome: {
+            type: 'number',
+            default: 100,
+            min: 50,
+            max: 300,
+            description: 'Initial income level',
+        },
+        newIncome: {
+            type: 'number',
+            default: 150,
+            min: 50,
+            max: 300,
+            description: 'New income level',
+        },
+        priceX: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 50,
+            description: 'Price of good X',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            min: 1,
+            max: 50,
+            description: 'Price of good Y',
+        },
+    },
+    generate: (params) => {
+        const M0 = params.initialIncome ?? 100;
+        const M1 = params.newIncome ?? 150;
+        const Px = params.priceX ?? 10;
+        const Py = params.priceY ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Budget Constraint - Income Change',
+                description: 'Effect of income change on the budget constraint',
+            },
+            parameters: {
+                M0: { value: M0, label: 'Initial Income', min: 50, max: 300 },
+                M1: { value: M1, label: 'New Income', min: 50, max: 300 },
+                Px: { value: Px, label: 'Price of X', min: 1, max: 50 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 50 },
+                // Initial intercepts
+                maxX0: { expression: 'M0 / Px', hidden: true },
+                maxY0: { expression: 'M0 / Py', hidden: true },
+                // New intercepts
+                maxX1: { expression: 'M1 / Px', hidden: true },
+                maxY1: { expression: 'M1 / Py', hidden: true },
+                // Max for chart bounds
+                chartMaxX: { expression: 'max(maxX0, maxX1) * 1.2', hidden: true },
+                chartMaxY: { expression: 'max(maxY0, maxY1) * 1.2', hidden: true },
+                // Income change
+                deltaM: { expression: 'M1 - M0', label: 'ΔIncome', readonly: true },
+                pctChange: {
+                    expression: '(M1 - M0) / M0 * 100',
+                    label: '% Change',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Income Effect on Budget Constraint',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Original budget line
+                        {
+                            id: 'budget-original',
+                            type: 'line',
+                            equation: 'M0 / Py - (Px / Py) * x',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Original (M₀)',
+                            domain: { min: 0, max: 'maxX0' },
+                        },
+                        // New budget line
+                        {
+                            id: 'budget-new',
+                            type: 'line',
+                            equation: 'M1 / Py - (Px / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'New (M₁)',
+                            domain: { min: 0, max: 'maxX1' },
+                        },
+                        // Shift arrow from origin line to new line
+                        {
+                            id: 'shift-arrow',
+                            type: 'arrow',
+                            x1: 'maxX0 / 2',
+                            y1: 'M0 / Py - (Px / Py) * maxX0 / 2',
+                            x2: 'maxX1 / 2',
+                            y2: 'M1 / Py - (Px / Py) * maxX1 / 2',
+                            color: '#16A34A',
+                            label: 'Shift',
+                        },
+                        // Original intercepts
+                        {
+                            id: 'x-intercept-0',
+                            type: 'point',
+                            x: 'maxX0',
+                            y: 0,
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'y-intercept-0',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY0',
+                            color: '#6B7280',
+                        },
+                        // New intercepts
+                        {
+                            id: 'x-intercept-1',
+                            type: 'point',
+                            x: 'maxX1',
+                            y: 0,
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'y-intercept-1',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY1',
+                            color: '#2563EB',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'original-label',
+                            text: 'M₀ = ${M0}',
+                            x: 'maxX0 * 0.6',
+                            y: 'M0 / Py - (Px / Py) * maxX0 * 0.6 + chartMaxY * 0.05',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'new-label',
+                            text: 'M₁ = ${M1}',
+                            x: 'maxX1 * 0.6',
+                            y: 'M1 / Py - (Px / Py) * maxX1 * 0.6 + chartMaxY * 0.05',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'change-label',
+                            text: 'ΔM = ${deltaM} (${pctChange:.1f}%)',
+                            x: 'chartMaxX * 0.6',
+                            y: 'chartMaxY * 0.9',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Budget Constraint with Price Change
+ *
+ * Shows how the budget constraint pivots when the price of one good changes,
+ * demonstrating the substitution effect graphically.
+ */
+const budgetConstraintPriceChange = {
+    id: 'budget_constraint_price_change',
+    name: 'Budget Constraint - Price Change',
+    description: 'Demonstrates how budget constraint pivots when price of good X changes. Price increase pivots inward; decrease pivots outward from Y-intercept.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['budget constraint', 'price change', 'pivot', 'substitution effect'],
+    parameters: {
+        income: {
+            type: 'number',
+            default: 100,
+            description: 'Consumer income',
+        },
+        initialPriceX: {
+            type: 'number',
+            default: 10,
+            description: 'Initial price of good X',
+        },
+        newPriceX: {
+            type: 'number',
+            default: 5,
+            description: 'New price of good X (after change)',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y (unchanged)',
+        },
+    },
+    generate: (params) => {
+        const M = params.income ?? 100;
+        const Px0 = params.initialPriceX ?? 10;
+        const Px1 = params.newPriceX ?? 5;
+        const Py = params.priceY ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Budget Constraint - Price Change',
+                description: 'Effect of price change on budget constraint (pivot)',
+            },
+            parameters: {
+                M: { value: M, label: 'Income', min: 50, max: 300 },
+                Px0: { value: Px0, label: 'Initial Px', min: 1, max: 50 },
+                Px1: { value: Px1, label: 'New Px', min: 1, max: 50 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 50 },
+                // Y-intercept (unchanged)
+                maxY: { expression: 'M / Py', hidden: true },
+                // X-intercepts
+                maxX0: { expression: 'M / Px0', hidden: true },
+                maxX1: { expression: 'M / Px1', hidden: true },
+                // Chart bounds
+                chartMaxX: { expression: 'max(maxX0, maxX1) * 1.2', hidden: true },
+                chartMaxY: { expression: 'maxY * 1.2', hidden: true },
+                // Slopes
+                slope0: { expression: '-Px0 / Py', label: 'Original Slope', readonly: true },
+                slope1: { expression: '-Px1 / Py', label: 'New Slope', readonly: true },
+                // Price change
+                deltaPx: { expression: 'Px1 - Px0', label: 'ΔPx', readonly: true },
+                pctPxChange: {
+                    expression: '(Px1 - Px0) / Px0 * 100',
+                    label: '% Px Change',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Price Change Effect on Budget Constraint',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Original budget line
+                        {
+                            id: 'budget-original',
+                            type: 'line',
+                            equation: 'M / Py - (Px0 / Py) * x',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Original (Px₀)',
+                            domain: { min: 0, max: 'maxX0' },
+                        },
+                        // New budget line
+                        {
+                            id: 'budget-new',
+                            type: 'line',
+                            equation: 'M / Py - (Px1 / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'New (Px₁)',
+                            domain: { min: 0, max: 'maxX1' },
+                        },
+                        // Pivot point (Y-intercept)
+                        {
+                            id: 'pivot-point',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY',
+                            color: '#7C3AED',
+                            label: 'Pivot Point',
+                        },
+                        // Original X-intercept
+                        {
+                            id: 'x-intercept-0',
+                            type: 'point',
+                            x: 'maxX0',
+                            y: 0,
+                            color: '#6B7280',
+                            label: 'M/Px₀',
+                        },
+                        // New X-intercept
+                        {
+                            id: 'x-intercept-1',
+                            type: 'point',
+                            x: 'maxX1',
+                            y: 0,
+                            color: '#2563EB',
+                            label: 'M/Px₁',
+                        },
+                        // Arc showing pivot
+                        {
+                            id: 'pivot-arc',
+                            type: 'parametric',
+                            x: 'maxX0 * cos(t)',
+                            y: 'maxX0 * sin(t) * (Py / Px0)',
+                            tMin: 0,
+                            tMax: 'atan2(maxY, maxX1) - atan2(maxY, maxX0)',
+                            color: '#16A34A',
+                            lineStyle: 'dotted',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'slope-original',
+                            text: 'Slope = ${slope0:.2f}',
+                            x: 'maxX0 * 0.4',
+                            y: 'M / Py - (Px0 / Py) * maxX0 * 0.4 + chartMaxY * 0.08',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'slope-new',
+                            text: 'Slope = ${slope1:.2f}',
+                            x: 'maxX1 * 0.5',
+                            y: 'M / Py - (Px1 / Py) * maxX1 * 0.5 - chartMaxY * 0.05',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'price-change-label',
+                            text: 'Px: ${Px0} → ${Px1} (${pctPxChange:.1f}%)',
+                            x: 'chartMaxX * 0.6',
+                            y: 'chartMaxY * 0.9',
+                            color: '#DC2626',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Kinked Budget Constraint
+ *
+ * Shows budget constraint with kink due to rationing, quantity discounts,
+ * welfare programs, or in-kind transfers (vouchers).
+ */
+const budgetConstraintKinked = {
+    id: 'budget_constraint_kinked',
+    name: 'Kinked Budget Constraint',
+    description: 'Budget constraint with a kink caused by rationing, quantity discounts, welfare programs, or in-kind transfers like food stamps.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['budget constraint', 'kinked', 'rationing', 'vouchers', 'welfare'],
+    parameters: {
+        income: {
+            type: 'number',
+            default: 100,
+            description: 'Consumer income',
+        },
+        priceX: {
+            type: 'number',
+            default: 10,
+            description: 'Price of good X',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y',
+        },
+        subsidizedUnits: {
+            type: 'number',
+            default: 5,
+            description: 'Units of X available at subsidized price',
+        },
+        subsidizedPrice: {
+            type: 'number',
+            default: 2,
+            description: 'Subsidized price for first units of X',
+        },
+    },
+    generate: (params) => {
+        const M = params.income ?? 100;
+        const Px = params.priceX ?? 10;
+        const Py = params.priceY ?? 5;
+        const Xsub = params.subsidizedUnits ?? 5;
+        const Pxsub = params.subsidizedPrice ?? 2;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Kinked Budget Constraint',
+                description: 'Budget constraint with subsidy/rationing kink',
+            },
+            parameters: {
+                M: { value: M, label: 'Income', min: 50, max: 300 },
+                Px: { value: Px, label: 'Market Price X', min: 1, max: 50 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 50 },
+                Xsub: { value: Xsub, label: 'Subsidized Units', min: 1, max: 20 },
+                Pxsub: { value: Pxsub, label: 'Subsidized Px', min: 0, max: 'Px - 1' },
+                // Y-intercept (all income on Y)
+                maxY: { expression: 'M / Py', hidden: true },
+                // Kink point calculations
+                kinkX: { expression: 'Xsub', hidden: true },
+                kinkY: { expression: '(M - Pxsub * Xsub) / Py', hidden: true },
+                // Money remaining after buying subsidized units
+                remainingM: { expression: 'M - Pxsub * Xsub', hidden: true },
+                // Max X if buying all subsidized then market price
+                maxX: { expression: 'Xsub + remainingM / Px', hidden: true },
+                // Chart bounds
+                chartMaxX: { expression: 'maxX * 1.2', hidden: true },
+                chartMaxY: { expression: 'maxY * 1.2', hidden: true },
+                // Subsidy value
+                subsidyValue: {
+                    expression: '(Px - Pxsub) * Xsub',
+                    label: 'Subsidy Value',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Kinked Budget Constraint (Subsidy Program)',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Subsidized region (steeper because lower price)
+                        {
+                            id: 'budget-subsidized',
+                            type: 'line',
+                            equation: 'M / Py - (Pxsub / Py) * x',
+                            color: '#22C55E',
+                            strokeWidth: 3,
+                            label: 'Subsidized (Px = ' + Pxsub + ')',
+                            domain: { min: 0, max: 'kinkX' },
+                        },
+                        // Market price region (flatter because higher price)
+                        {
+                            id: 'budget-market',
+                            type: 'line',
+                            equation: 'kinkY - (Px / Py) * (x - kinkX)',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Market Price (Px = ' + Px + ')',
+                            domain: { min: 'kinkX', max: 'maxX' },
+                        },
+                        // Counterfactual: no subsidy budget line
+                        {
+                            id: 'budget-no-subsidy',
+                            type: 'line',
+                            equation: 'M / Py - (Px / Py) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            label: 'Without Subsidy',
+                            domain: { min: 0, max: 'M / Px' },
+                        },
+                        // Kink point
+                        {
+                            id: 'kink-point',
+                            type: 'point',
+                            x: 'kinkX',
+                            y: 'kinkY',
+                            color: '#DC2626',
+                            label: 'Kink',
+                        },
+                        // Y-intercept
+                        {
+                            id: 'y-intercept',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY',
+                            color: '#22C55E',
+                        },
+                        // X-intercept
+                        {
+                            id: 'x-intercept',
+                            type: 'point',
+                            x: 'maxX',
+                            y: 0,
+                            color: '#2563EB',
+                        },
+                        // Vertical line at kink
+                        {
+                            id: 'kink-vertical',
+                            type: 'verticalLine',
+                            x: 'kinkX',
+                            color: '#DC2626',
+                            lineStyle: 'dotted',
+                            strokeWidth: 1,
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'subsidized-label',
+                            text: 'First ${Xsub} units at $${Pxsub}',
+                            x: 'kinkX * 0.3',
+                            y: 'chartMaxY * 0.85',
+                            color: '#22C55E',
+                        },
+                        {
+                            id: 'market-label',
+                            text: 'Additional units at $${Px}',
+                            x: 'kinkX + (maxX - kinkX) * 0.5',
+                            y: 'kinkY * 0.4',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'subsidy-value-label',
+                            text: 'Subsidy value = $${subsidyValue:.0f}',
+                            x: 'chartMaxX * 0.6',
+                            y: 'chartMaxY * 0.95',
+                            color: '#DC2626',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Budget Constraint with Endowment
+ *
+ * Shows budget constraint when consumer has an initial endowment of goods
+ * rather than just income. Common in general equilibrium analysis.
+ */
+const budgetConstraintEndowment = {
+    id: 'budget_constraint_endowment',
+    name: 'Budget Constraint with Endowment',
+    description: 'Budget constraint when consumer has an initial endowment of goods. The budget line passes through the endowment point, allowing both buying and selling.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['budget constraint', 'endowment', 'general equilibrium', 'trading'],
+    parameters: {
+        endowmentX: {
+            type: 'number',
+            default: 6,
+            description: 'Initial endowment of good X',
+        },
+        endowmentY: {
+            type: 'number',
+            default: 8,
+            description: 'Initial endowment of good Y',
+        },
+        priceX: {
+            type: 'number',
+            default: 10,
+            description: 'Price of good X',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y',
+        },
+    },
+    generate: (params) => {
+        const eX = params.endowmentX ?? 6;
+        const eY = params.endowmentY ?? 8;
+        const Px = params.priceX ?? 10;
+        const Py = params.priceY ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Budget Constraint with Endowment',
+                description: 'Budget constraint passing through initial endowment',
+            },
+            parameters: {
+                eX: { value: eX, label: 'Endowment X', min: 1, max: 20 },
+                eY: { value: eY, label: 'Endowment Y', min: 1, max: 20 },
+                Px: { value: Px, label: 'Price of X', min: 1, max: 50 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 50 },
+                // Wealth = value of endowment
+                W: { expression: 'Px * eX + Py * eY', label: 'Wealth', readonly: true },
+                // Intercepts
+                maxX: { expression: 'W / Px', hidden: true },
+                maxY: { expression: 'W / Py', hidden: true },
+                // Chart bounds
+                chartMaxX: { expression: 'maxX * 1.1', hidden: true },
+                chartMaxY: { expression: 'maxY * 1.1', hidden: true },
+                // Example chosen bundle
+                chosenX: { value: eX * 1.2, label: 'Chosen X', min: 0, max: 'maxX' },
+                chosenY: {
+                    expression: '(W - Px * chosenX) / Py',
+                    label: 'Chosen Y',
+                    readonly: true,
+                },
+                // Trade amounts
+                tradeX: { expression: 'chosenX - eX', label: 'Trade X', readonly: true },
+                tradeY: { expression: 'chosenY - eY', label: 'Trade Y', readonly: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Budget Constraint with Endowment',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Budget line
+                        {
+                            id: 'budget-line',
+                            type: 'line',
+                            equation: 'W / Py - (Px / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Budget Line',
+                            domain: { min: 0, max: 'maxX' },
+                        },
+                        // Endowment point
+                        {
+                            id: 'endowment',
+                            type: 'point',
+                            x: 'eX',
+                            y: 'eY',
+                            color: '#DC2626',
+                            size: 8,
+                            label: 'Endowment (E)',
+                            droplines: { x: true, y: true },
+                        },
+                        // Chosen bundle
+                        {
+                            id: 'chosen',
+                            type: 'point',
+                            x: 'chosenX',
+                            y: 'chosenY',
+                            color: '#16A34A',
+                            label: 'Chosen Bundle',
+                            droplines: { x: true, y: true },
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { chosenX: 'x' } },
+                                constraints: { bounds: { minX: 0, maxX: 'maxX' } },
+                            },
+                        },
+                        // Trade vector
+                        {
+                            id: 'trade-arrow',
+                            type: 'arrow',
+                            x1: 'eX',
+                            y1: 'eY',
+                            x2: 'chosenX',
+                            y2: 'chosenY',
+                            color: '#7C3AED',
+                            label: 'Trade',
+                        },
+                        // Regions: seller of X (left of endowment), buyer of X (right)
+                        {
+                            id: 'sell-x-region',
+                            type: 'area',
+                            topBoundary: 'budget-line',
+                            bottomBoundary: '0',
+                            leftBoundary: '0',
+                            rightBoundary: 'eX',
+                            color: '#EF4444',
+                            opacity: 0.1,
+                        },
+                        {
+                            id: 'buy-x-region',
+                            type: 'area',
+                            topBoundary: 'budget-line',
+                            bottomBoundary: '0',
+                            leftBoundary: 'eX',
+                            rightBoundary: 'maxX',
+                            color: '#22C55E',
+                            opacity: 0.1,
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'wealth-label',
+                            text: 'W = Px·eX + Py·eY = $${W:.0f}',
+                            x: 'chartMaxX * 0.5',
+                            y: 'chartMaxY * 0.95',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'sell-label',
+                            text: 'Sell X, Buy Y',
+                            x: 'eX * 0.3',
+                            y: 'chartMaxY * 0.7',
+                            color: '#EF4444',
+                        },
+                        {
+                            id: 'buy-label',
+                            text: 'Buy X, Sell Y',
+                            x: 'eX + (maxX - eX) * 0.5',
+                            y: 'chartMaxY * 0.3',
+                            color: '#22C55E',
+                        },
+                        {
+                            id: 'trade-label',
+                            text: 'ΔX=${tradeX:.1f}, ΔY=${tradeY:.1f}',
+                            x: '(eX + chosenX) / 2',
+                            y: '(eY + chosenY) / 2 + chartMaxY * 0.05',
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+// ============================================================================
+// PHASE 3.2: PREFERENCES AND INDIFFERENCE CURVES
+// ============================================================================
+/**
+ * Cobb-Douglas Indifference Curves
+ *
+ * Standard utility function: U(X,Y) = X^α * Y^(1-α)
+ * Indifference curves are convex hyperbolas.
+ */
+const indifferenceCurvesCobbDouglas = {
+    id: 'indifference_curves_cobb_douglas',
+    name: 'Cobb-Douglas Indifference Curves',
+    description: 'Standard convex indifference curves from Cobb-Douglas utility function U = X^α · Y^(1-α). Shows diminishing marginal rate of substitution.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['indifference curves', 'utility', 'Cobb-Douglas', 'MRS', 'preferences'],
+    parameters: {
+        alpha: {
+            type: 'number',
+            default: 0.5,
+            min: 0.1,
+            max: 0.9,
+            description: 'Exponent on good X (preference weight)',
+        },
+        utilityLevel: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 50,
+            description: 'Utility level for main indifference curve',
+        },
+    },
+    generate: (params) => {
+        const alpha = params.alpha ?? 0.5;
+        const U = params.utilityLevel ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Cobb-Douglas Indifference Curves',
+                description: 'U(X,Y) = X^α · Y^(1-α)',
+            },
+            parameters: {
+                alpha: { value: alpha, label: 'α (preference for X)', min: 0.1, max: 0.9, step: 0.05 },
+                U: { value: U, label: 'Utility Level', min: 1, max: 50 },
+                U_low: { expression: 'U * 0.5', hidden: true },
+                U_high: { expression: 'U * 1.5', hidden: true },
+                // Current point on IC
+                pointX: { value: U ** alpha, label: 'Point X', min: 0.5, max: 30 },
+                pointY: {
+                    expression: '(U / (pointX ^ alpha)) ^ (1 / (1 - alpha))',
+                    label: 'Point Y',
+                    readonly: true,
+                },
+                // MRS at current point: MRS = (α/(1-α)) * (Y/X)
+                MRS: {
+                    expression: '(alpha / (1 - alpha)) * (pointY / pointX)',
+                    label: 'MRS (|slope|)',
+                    readonly: true,
+                },
+                // Chart bounds
+                chartMax: { expression: 'max(pointX, pointY) * 2', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Cobb-Douglas Indifference Curves',
+                    xAxis: { label: 'Good X', min: 0.1, max: 'chartMax' },
+                    yAxis: { label: 'Good Y', min: 0.1, max: 'chartMax' },
+                    elements: [
+                        // Lower utility IC
+                        {
+                            id: 'ic-low',
+                            type: 'line',
+                            equation: '(U_low / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            label: 'U = ${U_low:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.9' },
+                        },
+                        // Main utility IC
+                        {
+                            id: 'ic-main',
+                            type: 'line',
+                            equation: '(U / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'U = ${U:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.9' },
+                        },
+                        // Higher utility IC
+                        {
+                            id: 'ic-high',
+                            type: 'line',
+                            equation: '(U_high / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            label: 'U = ${U_high:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.9' },
+                        },
+                        // Current point
+                        {
+                            id: 'current-point',
+                            type: 'point',
+                            x: 'pointX',
+                            y: 'pointY',
+                            color: '#16A34A',
+                            label: 'Current',
+                            droplines: { x: true, y: true },
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { pointX: 'x' } },
+                                constraints: { bounds: { minX: 0.5, maxX: 'chartMax * 0.8' } },
+                            },
+                        },
+                        // Tangent line showing MRS
+                        {
+                            id: 'tangent',
+                            type: 'line',
+                            equation: 'pointY - MRS * (x - pointX)',
+                            color: '#DC2626',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 'max(0.1, pointX - 5)', max: 'pointX + 5' },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'mrs-label',
+                            text: 'MRS = ${MRS:.2f}',
+                            x: 'pointX + chartMax * 0.1',
+                            y: 'pointY',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'utility-formula',
+                            text: 'U = X^${alpha:.2f} · Y^${(1-alpha):.2f}',
+                            x: 'chartMax * 0.6',
+                            y: 'chartMax * 0.9',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'preference-direction',
+                            text: '← Higher Utility →',
+                            x: 'chartMax * 0.7',
+                            y: 'chartMax * 0.5',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Perfect Substitutes Indifference Curves
+ *
+ * Linear utility function: U(X,Y) = aX + bY
+ * Indifference curves are straight lines.
+ */
+const indifferenceCurvesPerfectSubstitutes = {
+    id: 'indifference_curves_perfect_substitutes',
+    name: 'Perfect Substitutes Indifference Curves',
+    description: 'Linear indifference curves for perfect substitutes. U = aX + bY. Constant MRS regardless of bundle.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['indifference curves', 'perfect substitutes', 'linear utility', 'constant MRS'],
+    parameters: {
+        marginalUtilityX: {
+            type: 'number',
+            default: 2,
+            min: 1,
+            max: 10,
+            description: 'Marginal utility of X (a)',
+        },
+        marginalUtilityY: {
+            type: 'number',
+            default: 1,
+            min: 1,
+            max: 10,
+            description: 'Marginal utility of Y (b)',
+        },
+        utilityLevel: {
+            type: 'number',
+            default: 20,
+            min: 5,
+            max: 100,
+            description: 'Utility level',
+        },
+    },
+    generate: (params) => {
+        const a = params.marginalUtilityX ?? 2;
+        const b = params.marginalUtilityY ?? 1;
+        const U = params.utilityLevel ?? 20;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Perfect Substitutes',
+                description: 'Linear utility: U = aX + bY',
+            },
+            parameters: {
+                a: { value: a, label: 'MU of X (a)', min: 1, max: 10 },
+                b: { value: b, label: 'MU of Y (b)', min: 1, max: 10 },
+                U: { value: U, label: 'Utility Level', min: 5, max: 100 },
+                U_low: { expression: 'U * 0.6', hidden: true },
+                U_high: { expression: 'U * 1.4', hidden: true },
+                // Intercepts for main IC
+                maxX: { expression: 'U / a', hidden: true },
+                maxY: { expression: 'U / b', hidden: true },
+                // MRS = a/b (constant)
+                MRS: { expression: 'a / b', label: 'MRS (constant)', readonly: true },
+                // Chart bounds
+                chartMaxX: { expression: 'U_high / a * 1.1', hidden: true },
+                chartMaxY: { expression: 'U_high / b * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Perfect Substitutes: U = aX + bY',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Lower utility IC
+                        {
+                            id: 'ic-low',
+                            type: 'line',
+                            equation: '(U_low - a * x) / b',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            label: 'U = ${U_low:.0f}',
+                            domain: { min: 0, max: 'U_low / a' },
+                        },
+                        // Main utility IC
+                        {
+                            id: 'ic-main',
+                            type: 'line',
+                            equation: '(U - a * x) / b',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'U = ${U:.0f}',
+                            domain: { min: 0, max: 'maxX' },
+                        },
+                        // Higher utility IC
+                        {
+                            id: 'ic-high',
+                            type: 'line',
+                            equation: '(U_high - a * x) / b',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            label: 'U = ${U_high:.0f}',
+                            domain: { min: 0, max: 'U_high / a' },
+                        },
+                        // Intercept points for main IC
+                        {
+                            id: 'x-intercept',
+                            type: 'point',
+                            x: 'maxX',
+                            y: 0,
+                            color: '#7C3AED',
+                            label: 'U/a',
+                        },
+                        {
+                            id: 'y-intercept',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxY',
+                            color: '#7C3AED',
+                            label: 'U/b',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'mrs-label',
+                            text: 'MRS = a/b = ${MRS:.2f} (constant)',
+                            x: 'chartMaxX * 0.5',
+                            y: 'chartMaxY * 0.9',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'substitution-label',
+                            text: '${MRS:.1f} units of Y = 1 unit of X',
+                            x: 'chartMaxX * 0.5',
+                            y: 'chartMaxY * 0.82',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Perfect Complements Indifference Curves
+ *
+ * Leontief utility function: U(X,Y) = min(aX, bY)
+ * L-shaped indifference curves.
+ */
+const indifferenceCurvesPerfectComplements = {
+    id: 'indifference_curves_perfect_complements',
+    name: 'Perfect Complements Indifference Curves',
+    description: 'L-shaped indifference curves for perfect complements. U = min(aX, bY). Goods consumed in fixed proportions.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['indifference curves', 'perfect complements', 'Leontief', 'L-shaped', 'fixed proportions'],
+    parameters: {
+        ratioX: {
+            type: 'number',
+            default: 1,
+            min: 1,
+            max: 5,
+            description: 'Units of X per bundle (a)',
+        },
+        ratioY: {
+            type: 'number',
+            default: 2,
+            min: 1,
+            max: 5,
+            description: 'Units of Y per bundle (b)',
+        },
+        utilityLevel: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 30,
+            description: 'Utility level (number of bundles)',
+        },
+    },
+    generate: (params) => {
+        const a = params.ratioX ?? 1;
+        const b = params.ratioY ?? 2;
+        const U = params.utilityLevel ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Perfect Complements',
+                description: 'Leontief utility: U = min(X/a, Y/b)',
+            },
+            parameters: {
+                a: { value: a, label: 'X per bundle', min: 1, max: 5 },
+                b: { value: b, label: 'Y per bundle', min: 1, max: 5 },
+                U: { value: U, label: 'Bundles', min: 1, max: 30 },
+                U_low: { expression: 'U * 0.6', hidden: true },
+                U_high: { expression: 'U * 1.4', hidden: true },
+                // Kink points
+                kinkX: { expression: 'U * a', hidden: true },
+                kinkY: { expression: 'U * b', hidden: true },
+                kinkX_low: { expression: 'U_low * a', hidden: true },
+                kinkY_low: { expression: 'U_low * b', hidden: true },
+                kinkX_high: { expression: 'U_high * a', hidden: true },
+                kinkY_high: { expression: 'U_high * b', hidden: true },
+                // Chart bounds
+                chartMax: { expression: 'max(kinkX_high, kinkY_high) * 1.3', hidden: true },
+                // Optimal ratio
+                ratio: { expression: 'b / a', label: 'Optimal Y/X', readonly: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Perfect Complements: U = min(X/a, Y/b)',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMax' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMax' },
+                    elements: [
+                        // Optimal consumption ray
+                        {
+                            id: 'optimal-ray',
+                            type: 'line',
+                            equation: '(b / a) * x',
+                            color: '#16A34A',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Optimal Ratio',
+                            domain: { min: 0, max: 'chartMax * 0.9' },
+                        },
+                        // Lower utility IC (L-shape)
+                        {
+                            id: 'ic-low-horizontal',
+                            type: 'horizontalLine',
+                            y: 'kinkY_low',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            domain: { min: 'kinkX_low', max: 'chartMax' },
+                        },
+                        {
+                            id: 'ic-low-vertical',
+                            type: 'verticalLine',
+                            x: 'kinkX_low',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            domain: { min: 'kinkY_low', max: 'chartMax' },
+                        },
+                        // Main utility IC (L-shape)
+                        {
+                            id: 'ic-main-horizontal',
+                            type: 'horizontalLine',
+                            y: 'kinkY',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            domain: { min: 'kinkX', max: 'chartMax' },
+                        },
+                        {
+                            id: 'ic-main-vertical',
+                            type: 'verticalLine',
+                            x: 'kinkX',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            domain: { min: 'kinkY', max: 'chartMax' },
+                        },
+                        // Higher utility IC (L-shape)
+                        {
+                            id: 'ic-high-horizontal',
+                            type: 'horizontalLine',
+                            y: 'kinkY_high',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            domain: { min: 'kinkX_high', max: 'chartMax' },
+                        },
+                        {
+                            id: 'ic-high-vertical',
+                            type: 'verticalLine',
+                            x: 'kinkX_high',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            domain: { min: 'kinkY_high', max: 'chartMax' },
+                        },
+                        // Kink points
+                        {
+                            id: 'kink-low',
+                            type: 'point',
+                            x: 'kinkX_low',
+                            y: 'kinkY_low',
+                            color: '#93C5FD',
+                        },
+                        {
+                            id: 'kink-main',
+                            type: 'point',
+                            x: 'kinkX',
+                            y: 'kinkY',
+                            color: '#2563EB',
+                            label: 'Optimal',
+                        },
+                        {
+                            id: 'kink-high',
+                            type: 'point',
+                            x: 'kinkX_high',
+                            y: 'kinkY_high',
+                            color: '#1D4ED8',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'ratio-label',
+                            text: 'Consume ${a} X : ${b} Y',
+                            x: 'chartMax * 0.6',
+                            y: 'chartMax * 0.9',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'utility-label',
+                            text: 'U = min(X/${a}, Y/${b})',
+                            x: 'chartMax * 0.6',
+                            y: 'chartMax * 0.82',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'main-kink-label',
+                            text: '(${kinkX:.0f}, ${kinkY:.0f})',
+                            x: 'kinkX + chartMax * 0.05',
+                            y: 'kinkY + chartMax * 0.05',
+                            color: '#2563EB',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Optimal Consumer Choice
+ *
+ * Shows tangency between budget constraint and indifference curve
+ * at the utility-maximizing bundle.
+ */
+const consumerChoiceOptimal = {
+    id: 'consumer_choice_optimal',
+    name: 'Optimal Consumer Choice',
+    description: 'Utility maximization where indifference curve is tangent to budget constraint. MRS = Px/Py at optimum.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['utility maximization', 'optimal choice', 'tangency', 'MRS equals price ratio'],
+    parameters: {
+        income: {
+            type: 'number',
+            default: 100,
+            description: 'Consumer income',
+        },
+        priceX: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good X',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.5,
+            description: 'Preference parameter (Cobb-Douglas α)',
+        },
+    },
+    generate: (params) => {
+        const M = params.income ?? 100;
+        const Px = params.priceX ?? 5;
+        const Py = params.priceY ?? 5;
+        const alpha = params.alpha ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Optimal Consumer Choice',
+                description: 'Utility maximization with budget constraint',
+            },
+            parameters: {
+                M: { value: M, label: 'Income', min: 50, max: 200 },
+                Px: { value: Px, label: 'Price of X', min: 1, max: 20 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 20 },
+                alpha: { value: alpha, label: 'α', min: 0.1, max: 0.9, step: 0.05 },
+                // Budget constraint intercepts
+                maxX: { expression: 'M / Px', hidden: true },
+                maxY: { expression: 'M / Py', hidden: true },
+                // Optimal bundle (Cobb-Douglas solution)
+                optX: { expression: 'alpha * M / Px', label: 'Optimal X', readonly: true },
+                optY: {
+                    expression: '(1 - alpha) * M / Py',
+                    label: 'Optimal Y',
+                    readonly: true,
+                },
+                // Utility at optimum
+                U_opt: {
+                    expression: '(optX ^ alpha) * (optY ^ (1 - alpha))',
+                    label: 'Max Utility',
+                    readonly: true,
+                },
+                // MRS at optimum (should equal Px/Py)
+                MRS: {
+                    expression: '(alpha / (1 - alpha)) * (optY / optX)',
+                    label: 'MRS at optimum',
+                    readonly: true,
+                },
+                priceRatio: { expression: 'Px / Py', label: 'Px/Py', readonly: true },
+                // Lower utility ICs for comparison
+                U_low: { expression: 'U_opt * 0.6', hidden: true },
+                U_high: { expression: 'U_opt * 1.2', hidden: true },
+                // Chart bounds
+                chartMaxX: { expression: 'maxX * 1.1', hidden: true },
+                chartMaxY: { expression: 'maxY * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Utility Maximization: MRS = Px/Py',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Budget constraint
+                        {
+                            id: 'budget',
+                            type: 'line',
+                            equation: 'M / Py - (Px / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Budget Constraint',
+                            domain: { min: 0, max: 'maxX' },
+                        },
+                        // Suboptimal IC (attainable but not optimal)
+                        {
+                            id: 'ic-low',
+                            type: 'line',
+                            equation: '(U_low / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0.5, max: 'chartMaxX' },
+                        },
+                        // Optimal IC (tangent to budget)
+                        {
+                            id: 'ic-optimal',
+                            type: 'line',
+                            equation: '(U_opt / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'Optimal IC',
+                            domain: { min: 0.5, max: 'chartMaxX' },
+                        },
+                        // Unattainable IC (above budget)
+                        {
+                            id: 'ic-high',
+                            type: 'line',
+                            equation: '(U_high / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#EF4444',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0.5, max: 'chartMaxX' },
+                        },
+                        // Optimal point
+                        {
+                            id: 'optimum',
+                            type: 'point',
+                            x: 'optX',
+                            y: 'optY',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Optimum',
+                            droplines: { x: true, y: true },
+                        },
+                        // Tangent line at optimum (showing MRS = price ratio)
+                        {
+                            id: 'tangent',
+                            type: 'line',
+                            equation: 'optY - priceRatio * (x - optX)',
+                            color: '#7C3AED',
+                            strokeWidth: 1,
+                            lineStyle: 'dotted',
+                            domain: { min: 'max(0, optX - 8)', max: 'optX + 8' },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'opt-label',
+                            text: 'X* = ${optX:.1f}, Y* = ${optY:.1f}',
+                            x: 'optX + chartMaxX * 0.05',
+                            y: 'optY + chartMaxY * 0.05',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'tangency-label',
+                            text: 'MRS = Px/Py = ${priceRatio:.2f}',
+                            x: 'chartMaxX * 0.6',
+                            y: 'chartMaxY * 0.9',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'utility-label',
+                            text: 'U* = ${U_opt:.2f}',
+                            x: 'chartMaxX * 0.6',
+                            y: 'chartMaxY * 0.82',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'unattainable-label',
+                            text: 'Unattainable',
+                            x: 'chartMaxX * 0.8',
+                            y: '(U_high / ((chartMaxX * 0.8) ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#EF4444',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Income Consumption Curve (ICC) and Engel Curve
+ *
+ * Shows how optimal consumption changes with income,
+ * tracing out the ICC in good-space and the Engel curve.
+ */
+const incomeConsumptionCurve = {
+    id: 'income_consumption_curve',
+    name: 'Income Consumption Curve',
+    description: 'Traces optimal bundles as income changes, showing income expansion path. Engel curve shows quantity of X vs income.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['ICC', 'Engel curve', 'income effect', 'normal good', 'inferior good'],
+    parameters: {
+        priceX: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good X',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.4,
+            description: 'Preference parameter α',
+        },
+        incomeBase: {
+            type: 'number',
+            default: 50,
+            description: 'Base income level',
+        },
+        incomeCurrent: {
+            type: 'number',
+            default: 100,
+            description: 'Current income level',
+        },
+    },
+    generate: (params) => {
+        const Px = params.priceX ?? 5;
+        const Py = params.priceY ?? 5;
+        const alpha = params.alpha ?? 0.4;
+        const M_base = params.incomeBase ?? 50;
+        const M = params.incomeCurrent ?? 100;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Income Consumption Curve',
+                description: 'Optimal bundles as income varies',
+            },
+            parameters: {
+                Px: { value: Px, label: 'Price of X', min: 1, max: 20 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 20 },
+                alpha: { value: alpha, label: 'α', min: 0.1, max: 0.9, step: 0.05 },
+                M_base: { value: M_base, label: 'Base Income', min: 20, max: 100 },
+                M: { value: M, label: 'Current Income', min: 50, max: 200 },
+                M_high: { expression: 'M * 1.5', hidden: true },
+                // Budget constraint bounds
+                maxX: { expression: 'M / Px', hidden: true },
+                maxY: { expression: 'M / Py', hidden: true },
+                // Optimal bundles at different incomes
+                optX_base: { expression: 'alpha * M_base / Px', hidden: true },
+                optY_base: { expression: '(1 - alpha) * M_base / Py', hidden: true },
+                optX: { expression: 'alpha * M / Px', label: 'X*', readonly: true },
+                optY: { expression: '(1 - alpha) * M / Py', label: 'Y*', readonly: true },
+                optX_high: { expression: 'alpha * M_high / Px', hidden: true },
+                optY_high: { expression: '(1 - alpha) * M_high / Py', hidden: true },
+                // Income elasticity (for Cobb-Douglas, it's 1)
+                incomeElasticity: { value: 1, label: 'Income Elasticity', readonly: true },
+                // Chart bounds
+                chartMaxX: { expression: 'M_high / Px * 1.1', hidden: true },
+                chartMaxY: { expression: 'M_high / Py * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'icc',
+                    title: 'Income Consumption Curve (ICC)',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // Income Consumption Curve (for Cobb-Douglas, it's a ray through origin)
+                        {
+                            id: 'icc-line',
+                            type: 'line',
+                            equation: '((1 - alpha) / alpha) * (Px / Py) * x',
+                            color: '#7C3AED',
+                            strokeWidth: 3,
+                            label: 'ICC',
+                            domain: { min: 0, max: 'chartMaxX' },
+                        },
+                        // Budget constraints at different incomes
+                        {
+                            id: 'budget-base',
+                            type: 'line',
+                            equation: 'M_base / Py - (Px / Py) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'M_base / Px' },
+                        },
+                        {
+                            id: 'budget-current',
+                            type: 'line',
+                            equation: 'M / Py - (Px / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'Budget (M)',
+                            domain: { min: 0, max: 'maxX' },
+                        },
+                        {
+                            id: 'budget-high',
+                            type: 'line',
+                            equation: 'M_high / Py - (Px / Py) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'M_high / Px' },
+                        },
+                        // Optimal points
+                        {
+                            id: 'opt-base',
+                            type: 'point',
+                            x: 'optX_base',
+                            y: 'optY_base',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'opt-current',
+                            type: 'point',
+                            x: 'optX',
+                            y: 'optY',
+                            color: '#2563EB',
+                            size: 8,
+                            label: 'Current',
+                            droplines: { x: true, y: true },
+                        },
+                        {
+                            id: 'opt-high',
+                            type: 'point',
+                            x: 'optX_high',
+                            y: 'optY_high',
+                            color: '#6B7280',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'icc-label',
+                            text: 'Income Consumption Curve',
+                            x: 'chartMaxX * 0.7',
+                            y: '((1 - alpha) / alpha) * (Px / Py) * chartMaxX * 0.7 * 1.1',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'current-label',
+                            text: 'M = $${M}',
+                            x: 'optX + 2',
+                            y: 'optY + 2',
+                            color: '#2563EB',
+                        },
+                    ],
+                },
+                {
+                    id: 'engel',
+                    title: 'Engel Curve for Good X',
+                    xAxis: { label: 'Income (M)', min: 0, max: 'M_high * 1.1' },
+                    yAxis: { label: 'Quantity of X', min: 0, max: 'optX_high * 1.2' },
+                    elements: [
+                        // Engel curve: X = αM/Px
+                        {
+                            id: 'engel-curve',
+                            type: 'line',
+                            equation: 'alpha * x / Px',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'Engel Curve',
+                        },
+                        // Current income point
+                        {
+                            id: 'current-engel',
+                            type: 'point',
+                            x: 'M',
+                            y: 'optX',
+                            color: '#2563EB',
+                            label: 'Current',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'engel-formula',
+                            text: 'X* = αM/Px',
+                            x: 'M_high * 0.6',
+                            y: 'optX_high * 1.1',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'normal-label',
+                            text: 'Normal Good (upward sloping)',
+                            x: 'M_high * 0.5',
+                            y: 'optX_high * 0.3',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Price Consumption Curve (PCC) and Demand Curve Derivation
+ *
+ * Shows how optimal consumption changes as price varies,
+ * deriving the individual demand curve.
+ */
+const priceConsumptionCurve = {
+    id: 'price_consumption_curve',
+    name: 'Price Consumption Curve',
+    description: 'Traces optimal bundles as price of X changes, deriving the individual demand curve for X.',
+    category: 'consumer_theory',
+    level: 'undergraduate',
+    tags: ['PCC', 'demand derivation', 'price effect', 'substitution effect', 'income effect'],
+    parameters: {
+        income: {
+            type: 'number',
+            default: 100,
+            description: 'Consumer income',
+        },
+        priceY: {
+            type: 'number',
+            default: 5,
+            description: 'Price of good Y (fixed)',
+        },
+        priceXLow: {
+            type: 'number',
+            default: 2,
+            description: 'Low price of X',
+        },
+        priceXMid: {
+            type: 'number',
+            default: 5,
+            description: 'Medium price of X',
+        },
+        priceXHigh: {
+            type: 'number',
+            default: 10,
+            description: 'High price of X',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.5,
+            description: 'Preference parameter α',
+        },
+    },
+    generate: (params) => {
+        const M = params.income ?? 100;
+        const Py = params.priceY ?? 5;
+        const Px_low = params.priceXLow ?? 2;
+        const Px_mid = params.priceXMid ?? 5;
+        const Px_high = params.priceXHigh ?? 10;
+        const alpha = params.alpha ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Price Consumption Curve & Demand Derivation',
+                description: 'Deriving demand from utility maximization',
+            },
+            parameters: {
+                M: { value: M, label: 'Income', min: 50, max: 200 },
+                Py: { value: Py, label: 'Price of Y', min: 1, max: 20 },
+                Px_low: { value: Px_low, label: 'Low Px', min: 1, max: 10 },
+                Px_mid: { value: Px_mid, label: 'Mid Px', min: 2, max: 15 },
+                Px_high: { value: Px_high, label: 'High Px', min: 5, max: 25 },
+                alpha: { value: alpha, label: 'α', min: 0.1, max: 0.9, step: 0.05 },
+                // Y-intercept (always M/Py)
+                maxY: { expression: 'M / Py', hidden: true },
+                // X-intercepts at each price
+                maxX_low: { expression: 'M / Px_low', hidden: true },
+                maxX_mid: { expression: 'M / Px_mid', hidden: true },
+                maxX_high: { expression: 'M / Px_high', hidden: true },
+                // Optimal bundles at each price
+                optX_low: { expression: 'alpha * M / Px_low', hidden: true },
+                optY_low: { expression: '(1 - alpha) * M / Py', hidden: true },
+                optX_mid: { expression: 'alpha * M / Px_mid', label: 'X* (mid)', readonly: true },
+                optY_mid: { expression: '(1 - alpha) * M / Py', label: 'Y* (mid)', readonly: true },
+                optX_high: { expression: 'alpha * M / Px_high', hidden: true },
+                optY_high: { expression: '(1 - alpha) * M / Py', hidden: true },
+                // Chart bounds
+                chartMaxX: { expression: 'maxX_low * 1.1', hidden: true },
+                chartMaxY: { expression: 'maxY * 1.2', hidden: true },
+                priceMax: { expression: 'Px_high * 1.2', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'pcc',
+                    title: 'Price Consumption Curve (PCC)',
+                    xAxis: { label: 'Good X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'chartMaxY' },
+                    elements: [
+                        // PCC (for Cobb-Douglas, it's horizontal since Y* = (1-α)M/Py is constant)
+                        {
+                            id: 'pcc-line',
+                            type: 'horizontalLine',
+                            y: 'optY_mid',
+                            color: '#7C3AED',
+                            strokeWidth: 3,
+                            label: 'PCC',
+                        },
+                        // Budget lines at different prices
+                        {
+                            id: 'budget-low',
+                            type: 'line',
+                            equation: 'maxY - (Px_low / Py) * x',
+                            color: '#22C55E',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Px = $' + Px_low,
+                            domain: { min: 0, max: 'maxX_low' },
+                        },
+                        {
+                            id: 'budget-mid',
+                            type: 'line',
+                            equation: 'maxY - (Px_mid / Py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'Px = $' + Px_mid,
+                            domain: { min: 0, max: 'maxX_mid' },
+                        },
+                        {
+                            id: 'budget-high',
+                            type: 'line',
+                            equation: 'maxY - (Px_high / Py) * x',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Px = $' + Px_high,
+                            domain: { min: 0, max: 'maxX_high' },
+                        },
+                        // Optimal points
+                        {
+                            id: 'opt-low',
+                            type: 'point',
+                            x: 'optX_low',
+                            y: 'optY_low',
+                            color: '#22C55E',
+                            label: 'A',
+                        },
+                        {
+                            id: 'opt-mid',
+                            type: 'point',
+                            x: 'optX_mid',
+                            y: 'optY_mid',
+                            color: '#2563EB',
+                            size: 8,
+                            label: 'B',
+                        },
+                        {
+                            id: 'opt-high',
+                            type: 'point',
+                            x: 'optX_high',
+                            y: 'optY_high',
+                            color: '#DC2626',
+                            label: 'C',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'pcc-label',
+                            text: 'Price Consumption Curve',
+                            x: 'chartMaxX * 0.7',
+                            y: 'optY_mid + chartMaxY * 0.08',
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+                {
+                    id: 'demand',
+                    title: 'Individual Demand Curve',
+                    xAxis: { label: 'Quantity of X', min: 0, max: 'chartMaxX' },
+                    yAxis: { label: 'Price of X', min: 0, max: 'priceMax' },
+                    elements: [
+                        // Demand curve: Px = αM/X (inverse demand)
+                        {
+                            id: 'demand-curve',
+                            type: 'line',
+                            equation: 'alpha * M / x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand',
+                            domain: { min: 2, max: 'chartMaxX * 0.9' },
+                        },
+                        // Points from PCC
+                        {
+                            id: 'demand-low',
+                            type: 'point',
+                            x: 'optX_low',
+                            y: 'Px_low',
+                            color: '#22C55E',
+                            label: 'A',
+                            droplines: { x: true, y: true },
+                        },
+                        {
+                            id: 'demand-mid',
+                            type: 'point',
+                            x: 'optX_mid',
+                            y: 'Px_mid',
+                            color: '#2563EB',
+                            size: 8,
+                            label: 'B',
+                            droplines: { x: true, y: true },
+                        },
+                        {
+                            id: 'demand-high',
+                            type: 'point',
+                            x: 'optX_high',
+                            y: 'Px_high',
+                            color: '#DC2626',
+                            label: 'C',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'demand-formula',
+                            text: 'X* = αM/Px',
+                            x: 'chartMaxX * 0.7',
+                            y: 'priceMax * 0.8',
+                            color: '#2563EB',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export const consumerTemplates = [
+    // Phase 3.1: Budget Constraints
+    budgetConstraintBasic,
+    budgetConstraintIncomeChange,
+    budgetConstraintPriceChange,
+    budgetConstraintKinked,
+    budgetConstraintEndowment,
+    // Phase 3.2: Preferences and Indifference Curves
+    indifferenceCurvesCobbDouglas,
+    indifferenceCurvesPerfectSubstitutes,
+    indifferenceCurvesPerfectComplements,
+    consumerChoiceOptimal,
+    incomeConsumptionCurve,
+    priceConsumptionCurve,
+];
+//# sourceMappingURL=consumer.js.map