equilibria-mcp-server 1.0.0

package/dist/templates/advancedMicro.js

@@ -0,0 +1,834 @@
+/**
+ * Advanced Microeconomic Theory Templates
+ *
+ * Postgraduate-level templates for general equilibrium, contract theory, and consumer theory.
+ */
+/**
+ * Edgeworth Box
+ * General equilibrium with two consumers and two goods
+ */
+const edgeworthBox = {
+    id: 'edgeworth_box',
+    name: 'Edgeworth Box',
+    description: 'Two-person, two-good exchange economy showing the contract curve and Pareto efficient allocations.',
+    category: 'consumer_theory',
+    level: 'postgraduate',
+    tags: ['general equilibrium', 'Edgeworth box', 'Pareto efficiency', 'exchange economy'],
+    parameters: {
+        totalX: {
+            type: 'number',
+            default: 10,
+            description: 'Total endowment of good X',
+        },
+        totalY: {
+            type: 'number',
+            default: 10,
+            description: 'Total endowment of good Y',
+        },
+        alphaA: {
+            type: 'number',
+            default: 0.5,
+            description: 'Consumer A preference for X (Cobb-Douglas)',
+        },
+        alphaB: {
+            type: 'number',
+            default: 0.5,
+            description: 'Consumer B preference for X (Cobb-Douglas)',
+        },
+    },
+    generate: (params) => {
+        const Tx = params.totalX ?? 10;
+        const Ty = params.totalY ?? 10;
+        const alphaA = params.alphaA ?? 0.5;
+        const alphaB = params.alphaB ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Edgeworth Box',
+                description: 'Two-consumer exchange economy',
+            },
+            parameters: {
+                Tx: { value: Tx, label: 'Total X', min: 5, max: 20 },
+                Ty: { value: Ty, label: 'Total Y', min: 5, max: 20 },
+                alphaA: { value: alphaA, label: 'A preference (α)', min: 0.2, max: 0.8, step: 0.1 },
+                alphaB: { value: alphaB, label: 'B preference (β)', min: 0.2, max: 0.8, step: 0.1 },
+                // Initial endowment
+                omegaAx: { value: 3, label: 'A initial X' },
+                omegaAy: { value: 7, label: 'A initial Y' },
+                // B's endowment is residual
+                omegaBx: {
+                    expression: 'Tx - omegaAx',
+                    label: 'B initial X',
+                    readonly: true,
+                },
+                omegaBy: {
+                    expression: 'Ty - omegaAy',
+                    label: 'B initial Y',
+                    readonly: true,
+                },
+                // Current allocation for A
+                xA: { value: 5, label: 'A current X', min: 0.5, max: 9.5 },
+                yA: { value: 5, label: 'A current Y', min: 0.5, max: 9.5 },
+                // B's allocation is residual
+                xB: {
+                    expression: 'Tx - xA',
+                    label: 'B current X',
+                    readonly: true,
+                },
+                yB: {
+                    expression: 'Ty - yA',
+                    label: 'B current Y',
+                    readonly: true,
+                },
+                // MRS for each consumer
+                mrsA: {
+                    expression: '(alphaA * yA) / ((1 - alphaA) * xA)',
+                    label: 'MRS_A',
+                    readonly: true,
+                },
+                mrsB: {
+                    expression: '(alphaB * yB) / ((1 - alphaB) * xB)',
+                    label: 'MRS_B',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'box',
+                    title: 'Edgeworth Box',
+                    xAxis: { label: 'Good X (A origin at left)', min: 0, max: 'Tx' },
+                    yAxis: { label: 'Good Y (A origin at bottom)', min: 0, max: 'Ty' },
+                    elements: [
+                        // Box boundary (right side for B's origin)
+                        {
+                            id: 'right-boundary',
+                            type: 'verticalLine',
+                            x: 'Tx',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                        },
+                        {
+                            id: 'top-boundary',
+                            type: 'horizontalLine',
+                            y: 'Ty',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                        },
+                        // Contract curve (locus of tangencies)
+                        // For Cobb-Douglas: yA = (αA(1-αB)/αB(1-αA)) * (Ty/Tx) * xA
+                        {
+                            id: 'contract-curve',
+                            type: 'line',
+                            equation: '(alphaA * (1 - alphaB) / (alphaB * (1 - alphaA))) * (Ty / Tx) * x',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'Contract Curve',
+                        },
+                        // A's indifference curve through current allocation
+                        // Cobb-Douglas: yA = (uA / xA^αA)^(1/(1-αA))
+                        {
+                            id: 'ic-A',
+                            type: 'line',
+                            equation: '((xA^alphaA * yA^(1-alphaA)) / x^alphaA)^(1/(1-alphaA))',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'IC_A',
+                        },
+                        // B's indifference curve (from B's origin at top-right)
+                        // Need to invert: plot in A's coordinates
+                        {
+                            id: 'ic-B',
+                            type: 'line',
+                            equation: 'Ty - ((xB^alphaB * yB^(1-alphaB)) / (Tx - x)^alphaB)^(1/(1-alphaB))',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'IC_B',
+                        },
+                        // Initial endowment
+                        {
+                            id: 'endowment',
+                            type: 'point',
+                            x: 'omegaAx',
+                            y: 'omegaAy',
+                            color: '#6B7280',
+                            size: 10,
+                            label: 'ω (Endowment)',
+                        },
+                        // Current allocation
+                        {
+                            id: 'current',
+                            type: 'point',
+                            x: 'xA',
+                            y: 'yA',
+                            color: '#7C3AED',
+                            size: 12,
+                            label: 'Allocation',
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { xA: 'x', yA: 'y' } },
+                                constraints: { bounds: { minX: 0.5, maxX: 9.5, minY: 0.5, maxY: 9.5 } },
+                            },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'A-origin',
+                            text: 'A',
+                            x: 0.5,
+                            y: 0.5,
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'B-origin',
+                            text: 'B',
+                            x: 'Tx - 0.5',
+                            y: 'Ty - 0.5',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'pareto-label',
+                            text: 'Contract Curve (Pareto Set)',
+                            x: 'Tx * 0.6',
+                            y: '(alphaA * (1 - alphaB) / (alphaB * (1 - alphaA))) * (Ty / Tx) * Tx * 0.6 + 0.5',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'mrs-comparison',
+                            text: 'MRS_A = ${mrsA:.2f}, MRS_B = ${mrsB:.2f}',
+                            x: 'Tx * 0.5',
+                            y: 1,
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Slutsky Equation Decomposition
+ * Income and substitution effects
+ */
+const slutskyEquation = {
+    id: 'slutsky_equation',
+    name: 'Slutsky Decomposition',
+    description: 'Decomposes the total effect of a price change into substitution and income effects.',
+    category: 'consumer_theory',
+    level: 'postgraduate',
+    tags: ['Slutsky', 'income effect', 'substitution effect', 'consumer theory', 'demand'],
+    parameters: {
+        initialPx: {
+            type: 'number',
+            default: 2,
+            description: 'Initial price of X',
+        },
+        newPx: {
+            type: 'number',
+            default: 4,
+            description: 'New price of X',
+        },
+        income: {
+            type: 'number',
+            default: 100,
+            description: 'Consumer income',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.5,
+            description: 'Preference for X (Cobb-Douglas)',
+        },
+    },
+    generate: (params) => {
+        const px0 = params.initialPx ?? 2;
+        const px1 = params.newPx ?? 4;
+        const M = params.income ?? 100;
+        const alpha = params.alpha ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Slutsky Decomposition',
+                description: 'Income and substitution effects of price change',
+            },
+            parameters: {
+                px0: { value: px0, label: 'Initial P_X', min: 1, max: 5, step: 0.5 },
+                px1: { value: px1, label: 'New P_X', min: 1, max: 8, step: 0.5 },
+                py: { value: 1, label: 'P_Y (fixed)' },
+                M: { value: M, label: 'Income', min: 50, max: 200 },
+                alpha: { value: alpha, label: 'α', min: 0.3, max: 0.7, step: 0.05 },
+                // Initial optimal bundle
+                x0: {
+                    expression: 'alpha * M / px0',
+                    label: 'Initial X',
+                    readonly: true,
+                },
+                y0: {
+                    expression: '(1 - alpha) * M / py',
+                    label: 'Initial Y',
+                    readonly: true,
+                },
+                // Final optimal bundle
+                x1: {
+                    expression: 'alpha * M / px1',
+                    label: 'Final X',
+                    readonly: true,
+                },
+                y1: {
+                    expression: '(1 - alpha) * M / py',
+                    label: 'Final Y',
+                    readonly: true,
+                },
+                // Compensated income (Slutsky)
+                M_comp: {
+                    expression: 'px1 * x0 + py * y0',
+                    label: 'Compensated Income',
+                    readonly: true,
+                },
+                // Compensated bundle (on new budget, afford old bundle)
+                x_comp: {
+                    expression: 'alpha * M_comp / px1',
+                    label: 'Compensated X',
+                    readonly: true,
+                },
+                y_comp: {
+                    expression: '(1 - alpha) * M_comp / py',
+                    label: 'Compensated Y',
+                    readonly: true,
+                },
+                // Effects
+                totalEffect: {
+                    expression: 'x1 - x0',
+                    label: 'Total Effect',
+                    readonly: true,
+                },
+                substitutionEffect: {
+                    expression: 'x_comp - x0',
+                    label: 'Substitution Effect',
+                    readonly: true,
+                },
+                incomeEffect: {
+                    expression: 'x1 - x_comp',
+                    label: 'Income Effect',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Slutsky Decomposition',
+                    xAxis: { label: 'Good X', min: 0, max: 'max(x0, M/px1) * 1.3' },
+                    yAxis: { label: 'Good Y', min: 0, max: 'M / py * 1.3' },
+                    elements: [
+                        // Initial budget line
+                        {
+                            id: 'budget0',
+                            type: 'line',
+                            equation: 'M / py - (px0 / py) * x',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'Initial Budget',
+                            curveLabel: { text: 'BL₀', x: 'M / px0 * 0.9', position: 'below' },
+                        },
+                        // New budget line
+                        {
+                            id: 'budget1',
+                            type: 'line',
+                            equation: 'M / py - (px1 / py) * x',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'New Budget',
+                            curveLabel: { text: 'BL₁', x: 'M / px1 * 0.9', position: 'below' },
+                        },
+                        // Compensated budget line (parallel to new, through old bundle)
+                        {
+                            id: 'budget-comp',
+                            type: 'line',
+                            equation: 'M_comp / py - (px1 / py) * x',
+                            color: '#F59E0B',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Compensated Budget',
+                        },
+                        // Initial indifference curve
+                        {
+                            id: 'ic0',
+                            type: 'line',
+                            equation: '((x0^alpha * y0^(1-alpha)) / x^alpha)^(1/(1-alpha))',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            label: 'IC₀',
+                        },
+                        // Final indifference curve
+                        {
+                            id: 'ic1',
+                            type: 'line',
+                            equation: '((x1^alpha * y1^(1-alpha)) / x^alpha)^(1/(1-alpha))',
+                            color: '#FCA5A5',
+                            strokeWidth: 2,
+                            label: 'IC₁',
+                        },
+                        // Initial bundle (A)
+                        {
+                            id: 'bundleA',
+                            type: 'point',
+                            x: 'x0',
+                            y: 'y0',
+                            color: '#2563EB',
+                            size: 10,
+                            label: 'A (Initial)',
+                        },
+                        // Compensated bundle (B)
+                        {
+                            id: 'bundleB',
+                            type: 'point',
+                            x: 'x_comp',
+                            y: 'y_comp',
+                            color: '#F59E0B',
+                            size: 10,
+                            label: 'B (Compensated)',
+                        },
+                        // Final bundle (C)
+                        {
+                            id: 'bundleC',
+                            type: 'point',
+                            x: 'x1',
+                            y: 'y1',
+                            color: '#DC2626',
+                            size: 10,
+                            label: 'C (Final)',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'sub-effect',
+                            text: 'SE = ${substitutionEffect:.2f} (A→B)',
+                            x: '(x0 + x_comp) / 2',
+                            y: 'max(y0, y_comp) + 5',
+                            color: '#F59E0B',
+                        },
+                        {
+                            id: 'inc-effect',
+                            text: 'IE = ${incomeEffect:.2f} (B→C)',
+                            x: '(x_comp + x1) / 2',
+                            y: 'min(y_comp, y1) - 5',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'total-effect',
+                            text: 'Total = ${totalEffect:.2f}',
+                            x: 5,
+                            y: 'M / py * 1.1',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Principal-Agent Model
+ * Moral hazard with hidden action
+ */
+const principalAgent = {
+    id: 'principal_agent',
+    name: 'Principal-Agent Model',
+    description: 'Shows optimal contracting under moral hazard with effort incentives and participation constraints.',
+    category: 'market_structures',
+    level: 'postgraduate',
+    tags: ['principal-agent', 'moral hazard', 'incentives', 'contract theory', 'hidden action'],
+    parameters: {
+        highOutput: {
+            type: 'number',
+            default: 100,
+            description: 'Output if successful (Q_H)',
+        },
+        lowOutput: {
+            type: 'number',
+            default: 20,
+            description: 'Output if unsuccessful (Q_L)',
+        },
+        effortCost: {
+            type: 'number',
+            default: 10,
+            description: 'Cost of high effort (c)',
+        },
+        probHighEffort: {
+            type: 'number',
+            default: 0.8,
+            description: 'P(success | high effort)',
+        },
+        probLowEffort: {
+            type: 'number',
+            default: 0.3,
+            description: 'P(success | low effort)',
+        },
+        reservation: {
+            type: 'number',
+            default: 5,
+            description: 'Agent reservation utility',
+        },
+    },
+    generate: (params) => {
+        const QH = params.highOutput ?? 100;
+        const QL = params.lowOutput ?? 20;
+        const c = params.effortCost ?? 10;
+        const pH = params.probHighEffort ?? 0.8;
+        const pL = params.probLowEffort ?? 0.3;
+        const uBar = params.reservation ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Principal-Agent Problem',
+                description: 'Optimal incentive contract under moral hazard',
+            },
+            parameters: {
+                QH: { value: QH, label: 'High Output (Q_H)', min: 50, max: 200 },
+                QL: { value: QL, label: 'Low Output (Q_L)', min: 0, max: 50 },
+                c: { value: c, label: 'Effort Cost (c)', min: 1, max: 30 },
+                pH: { value: pH, label: 'P(H|effort)', min: 0.5, max: 0.95, step: 0.05 },
+                pL: { value: pL, label: 'P(H|shirk)', min: 0.1, max: 0.5, step: 0.05 },
+                uBar: { value: uBar, label: 'Reservation Utility', min: 0, max: 20 },
+                // Likelihood ratio
+                LR: {
+                    expression: '(pH - pL) / pL',
+                    label: 'Likelihood Ratio',
+                    readonly: true,
+                },
+                // First-best wage (observable effort)
+                wFB: {
+                    expression: '(uBar + c)^2',
+                    label: 'First-Best Wage',
+                    readonly: true,
+                },
+                // Second-best wages (sqrt utility: u = sqrt(w))
+                // IC: pH*sqrt(wH) + (1-pH)*sqrt(wL) - c >= pL*sqrt(wH) + (1-pL)*sqrt(wL)
+                // PC: pH*sqrt(wH) + (1-pH)*sqrt(wL) - c >= uBar
+                // Solution: sqrt(wL) = uBar + c - pH*c/(pH-pL)
+                //           sqrt(wH) = uBar + c + (1-pH)*c/(pH-pL)
+                sqrtWL: {
+                    expression: 'max(0, uBar + c - pH * c / (pH - pL))',
+                    label: 'sqrt(w_L)',
+                    readonly: true,
+                },
+                sqrtWH: {
+                    expression: 'uBar + c + (1 - pH) * c / (pH - pL)',
+                    label: 'sqrt(w_H)',
+                    readonly: true,
+                },
+                wL: {
+                    expression: 'sqrtWL^2',
+                    label: 'w_L (Low output)',
+                    readonly: true,
+                },
+                wH: {
+                    expression: 'sqrtWH^2',
+                    label: 'w_H (High output)',
+                    readonly: true,
+                },
+                // Expected wage
+                expectedWage: {
+                    expression: 'pH * wH + (1 - pH) * wL',
+                    label: 'E[wage]',
+                    readonly: true,
+                },
+                // Principal's expected profit
+                principalProfit: {
+                    expression: 'pH * (QH - wH) + (1 - pH) * (QL - wL)',
+                    label: 'E[Profit]',
+                    readonly: true,
+                },
+                // Information rent
+                infoRent: {
+                    expression: 'expectedWage - wFB',
+                    label: 'Information Rent',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'contract',
+                    title: 'Optimal Contract',
+                    xAxis: { label: 'Wage if Low Output (w_L)', min: 0, max: 'wH * 1.2' },
+                    yAxis: { label: 'Wage if High Output (w_H)', min: 0, max: 'wH * 1.5' },
+                    elements: [
+                        // IC constraint: (pH-pL)(sqrt(wH) - sqrt(wL)) = c
+                        // sqrt(wH) = sqrt(wL) + c/(pH-pL)
+                        {
+                            id: 'ic',
+                            type: 'line',
+                            equation: '(sqrt(x) + c/(pH-pL))^2',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'IC (binding)',
+                            curveLabel: { text: 'IC', x: 'wL * 0.8', position: 'above' },
+                        },
+                        // PC constraint: pH*sqrt(wH) + (1-pH)*sqrt(wL) - c = uBar
+                        // sqrt(wH) = (uBar + c - (1-pH)*sqrt(wL)) / pH
+                        {
+                            id: 'pc',
+                            type: 'line',
+                            equation: '((uBar + c - (1-pH)*sqrt(x)) / pH)^2',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'PC (binding)',
+                            curveLabel: { text: 'PC', x: 'wL * 0.5', position: 'below' },
+                        },
+                        // 45-degree line (equal wages)
+                        {
+                            id: 'equal',
+                            type: 'line',
+                            equation: 'x',
+                            color: '#6B7280',
+                            lineStyle: 'dotted',
+                            strokeWidth: 1,
+                        },
+                        // Optimal contract
+                        {
+                            id: 'optimal',
+                            type: 'point',
+                            x: 'wL',
+                            y: 'wH',
+                            color: '#16A34A',
+                            size: 12,
+                            label: 'Optimal Contract',
+                            droplines: { x: 'w_L*', y: 'w_H*' },
+                        },
+                        // First-best (equal wages)
+                        {
+                            id: 'firstbest',
+                            type: 'point',
+                            x: 'wFB',
+                            y: 'wFB',
+                            color: '#F59E0B',
+                            size: 10,
+                            label: 'First Best',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'contract-values',
+                            text: 'w_L* = ${wL:.1f}, w_H* = ${wH:.1f}',
+                            x: 'wL + 5',
+                            y: 'wH + 10',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'incentive-note',
+                            text: 'Gap = incentive for effort',
+                            x: '(wL + wH) / 2',
+                            y: '(wL + wH) / 2 + 20',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'profit-label',
+                            text: 'E[Profit] = ${principalProfit:.1f}',
+                            x: 5,
+                            y: 'wH * 1.3',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Mechanism Design / Revelation Principle
+ * Simplified two-type screening model
+ */
+const mechanismDesign = {
+    id: 'mechanism_design',
+    name: 'Mechanism Design',
+    description: 'Two-type screening model showing incentive-compatible mechanisms under adverse selection.',
+    category: 'market_structures',
+    level: 'postgraduate',
+    tags: ['mechanism design', 'adverse selection', 'screening', 'revelation principle', 'IC'],
+    parameters: {
+        thetaH: {
+            type: 'number',
+            default: 2,
+            description: 'High type valuation parameter',
+        },
+        thetaL: {
+            type: 'number',
+            default: 1,
+            description: 'Low type valuation parameter',
+        },
+        probHigh: {
+            type: 'number',
+            default: 0.5,
+            description: 'Probability of high type',
+        },
+        costParam: {
+            type: 'number',
+            default: 0.5,
+            description: 'Quadratic cost parameter',
+        },
+    },
+    generate: (params) => {
+        const tH = params.thetaH ?? 2;
+        const tL = params.thetaL ?? 1;
+        const lambda = params.probHigh ?? 0.5;
+        const c = params.costParam ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Mechanism Design',
+                description: 'Optimal screening with two types',
+            },
+            parameters: {
+                tH: { value: tH, label: 'θ_H', min: 1.5, max: 3, step: 0.1 },
+                tL: { value: tL, label: 'θ_L', min: 0.5, max: 1.5, step: 0.1 },
+                lambda: { value: lambda, label: 'P(θ_H)', min: 0.2, max: 0.8, step: 0.1 },
+                c: { value: c, label: 'Cost param', min: 0.2, max: 1, step: 0.1 },
+                // First-best quantities: θ = c*q => q = θ/c
+                qFB_H: {
+                    expression: 'tH / c',
+                    label: 'q*_H (First Best)',
+                    readonly: true,
+                },
+                qFB_L: {
+                    expression: 'tL / c',
+                    label: 'q*_L (First Best)',
+                    readonly: true,
+                },
+                // Second-best: high type gets first-best, low type distorted down
+                qSB_H: {
+                    expression: 'tH / c',
+                    label: 'q_H (Second Best)',
+                    readonly: true,
+                },
+                qSB_L: {
+                    expression: 'tL / c - lambda * (tH - tL) / ((1 - lambda) * c)',
+                    label: 'q_L (Second Best)',
+                    readonly: true,
+                },
+                // Surplus calculations
+                welfareFirstBest: {
+                    expression: 'lambda * (tH * qFB_H - 0.5 * c * qFB_H^2) + (1-lambda) * (tL * qFB_L - 0.5 * c * qFB_L^2)',
+                    label: 'First-Best Welfare',
+                    readonly: true,
+                },
+                informationRent: {
+                    expression: 'lambda * (tH - tL) * max(0, qSB_L)',
+                    label: 'Information Rent',
+                    readonly: true,
+                },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Optimal Mechanism',
+                    xAxis: { label: 'Quantity (q)', min: 0, max: 'qFB_H * 1.3' },
+                    yAxis: { label: 'Marginal Value / Cost', min: 0, max: 'tH * 1.2' },
+                    elements: [
+                        // High type marginal value
+                        {
+                            id: 'mv-high',
+                            type: 'horizontalLine',
+                            y: 'tH',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'θ_H',
+                        },
+                        // Low type marginal value
+                        {
+                            id: 'mv-low',
+                            type: 'horizontalLine',
+                            y: 'tL',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'θ_L',
+                        },
+                        // Marginal cost
+                        {
+                            id: 'mc',
+                            type: 'line',
+                            equation: 'c * x',
+                            color: '#16A34A',
+                            strokeWidth: 2,
+                            label: 'MC = cq',
+                        },
+                        // Virtual marginal value for low type
+                        {
+                            id: 'virtual-mv',
+                            type: 'horizontalLine',
+                            y: 'tL - lambda * (tH - tL) / (1 - lambda)',
+                            color: '#F59E0B',
+                            lineStyle: 'dashed',
+                            strokeWidth: 2,
+                            label: 'Virtual MV',
+                        },
+                        // First-best high type
+                        {
+                            id: 'fb-high',
+                            type: 'point',
+                            x: 'qFB_H',
+                            y: 'tH',
+                            color: '#2563EB',
+                            size: 10,
+                            label: 'FB_H',
+                            droplines: { x: true, y: false },
+                        },
+                        // First-best low type
+                        {
+                            id: 'fb-low',
+                            type: 'point',
+                            x: 'qFB_L',
+                            y: 'tL',
+                            color: '#DC2626',
+                            size: 10,
+                            label: 'FB_L',
+                            droplines: { x: true, y: false },
+                        },
+                        // Second-best low type (distorted)
+                        {
+                            id: 'sb-low',
+                            type: 'point',
+                            x: 'max(0, qSB_L)',
+                            y: 'tL',
+                            color: '#F59E0B',
+                            size: 12,
+                            label: 'SB_L',
+                            droplines: { x: true, y: false },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'distortion',
+                            text: 'Downward distortion',
+                            x: '(qFB_L + max(0, qSB_L)) / 2',
+                            y: 'tL + 0.3',
+                            color: '#F59E0B',
+                        },
+                        {
+                            id: 'no-distortion-top',
+                            text: 'No distortion at top',
+                            x: 'qFB_H * 0.7',
+                            y: 'tH + 0.2',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'rent-label',
+                            text: 'Info rent = ${informationRent:.2f}',
+                            x: 'qFB_H * 0.8',
+                            y: 'tL * 0.5',
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+export const advancedMicroTemplates = [
+    edgeworthBox,
+    slutskyEquation,
+    principalAgent,
+    mechanismDesign,
+];
+//# sourceMappingURL=advancedMicro.js.map