equilibria-mcp-server 1.0.0

package/dist/templates/marketStructures.js

@@ -0,0 +1,1135 @@
+/**
+ * Market Structures Templates
+ *
+ * Templates for market structure models including perfect competition,
+ * monopoly, and price discrimination.
+ *
+ * Phase 3.4: Market Structures - Perfect Competition & Monopoly
+ */
+// ============================================================================
+// PHASE 3.4: MARKET STRUCTURES
+// ============================================================================
+/**
+ * Perfect Competition - Short Run
+ *
+ * Shows individual firm facing horizontal demand at market price,
+ * profit maximization where P = MC, and short-run profit/loss.
+ */
+const perfectCompetitionShortRun = {
+    id: 'perfect_competition_short_run',
+    name: 'Perfect Competition - Short Run',
+    description: 'Price-taking firm in perfect competition. Firm faces horizontal demand at market price and produces where P = MC. Shows profit/loss as shaded area.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['perfect competition', 'price taker', 'profit maximization', 'short run'],
+    parameters: {
+        marketPrice: {
+            type: 'number',
+            default: 12,
+            min: 5,
+            max: 25,
+            description: 'Market price (exogenous to firm)',
+        },
+        fixedCost: {
+            type: 'number',
+            default: 20,
+            min: 0,
+            max: 100,
+            description: 'Total fixed cost (TFC)',
+        },
+        mcIntercept: {
+            type: 'number',
+            default: 2,
+            min: 0,
+            max: 10,
+            description: 'MC curve intercept',
+        },
+        mcSlope: {
+            type: 'number',
+            default: 0.5,
+            min: 0.1,
+            max: 2,
+            description: 'MC curve slope',
+        },
+    },
+    generate: (params) => {
+        const P = params.marketPrice ?? 12;
+        const TFC = params.fixedCost ?? 20;
+        const mc0 = params.mcIntercept ?? 2;
+        const mcSlope = params.mcSlope ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Perfect Competition - Short Run',
+                description: 'Profit maximization: P = MC',
+            },
+            parameters: {
+                P: { value: P, label: 'Market Price', min: 5, max: 25 },
+                TFC: { value: TFC, label: 'Fixed Cost', min: 0, max: 100 },
+                mc0: { value: mc0, label: 'MC intercept', min: 0, max: 10 },
+                mcSlope: { value: mcSlope, label: 'MC slope', min: 0.1, max: 2, step: 0.1 },
+                // Optimal quantity where P = MC: P = mc0 + mcSlope * Q => Q = (P - mc0) / mcSlope
+                Q_star: {
+                    expression: 'max(0, (P - mc0) / mcSlope)',
+                    label: 'Q*',
+                    readonly: true,
+                },
+                // AVC = mc0 + (mcSlope/2) * Q (integral of MC)
+                AVC_star: {
+                    expression: 'mc0 + (mcSlope / 2) * Q_star',
+                    label: 'AVC*',
+                    readonly: true,
+                },
+                // ATC = AVC + AFC = AVC + TFC/Q
+                ATC_star: {
+                    expression: 'AVC_star + TFC / max(1, Q_star)',
+                    label: 'ATC*',
+                    readonly: true,
+                },
+                // Total Revenue
+                TR: { expression: 'P * Q_star', label: 'Total Revenue', readonly: true },
+                // Total Cost = TFC + TVC where TVC = integral of MC
+                TC: {
+                    expression: 'TFC + mc0 * Q_star + (mcSlope / 2) * Q_star * Q_star',
+                    label: 'Total Cost',
+                    readonly: true,
+                },
+                // Profit
+                profit: { expression: 'TR - TC', label: 'Profit', readonly: true },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_star * 2', hidden: true },
+                chartMaxP: { expression: 'max(P, ATC_star) * 1.5', hidden: true },
+                // Shutdown point (P = min AVC)
+                shutdownP: { expression: 'mc0', label: 'Shutdown Price', readonly: true },
+            },
+            charts: [
+                {
+                    id: 'firm',
+                    title: 'Individual Firm',
+                    xAxis: { label: 'Quantity (q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price, Cost', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Profit/Loss area
+                        {
+                            id: 'profit-area',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'ATC_star',
+                            x2: 'Q_star',
+                            y2: 'P',
+                            fill: 'profit > 0 ? "#22C55E" : "#EF4444"',
+                            opacity: 0.3,
+                            label: 'profit > 0 ? "Profit" : "Loss"',
+                        },
+                        // Demand = MR = AR = P (horizontal line)
+                        {
+                            id: 'demand',
+                            type: 'horizontalLine',
+                            y: 'P',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'D = MR = AR = P',
+                        },
+                        // MC curve
+                        {
+                            id: 'mc',
+                            type: 'line',
+                            equation: 'mc0 + mcSlope * x',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC',
+                        },
+                        // AVC curve: AVC = mc0 + (mcSlope/2) * Q
+                        {
+                            id: 'avc',
+                            type: 'line',
+                            equation: 'mc0 + (mcSlope / 2) * x',
+                            color: '#F59E0B',
+                            strokeWidth: 2,
+                            label: 'AVC',
+                            domain: { min: 0.5, max: 'chartMaxQ' },
+                        },
+                        // ATC curve: ATC = TFC/Q + AVC
+                        {
+                            id: 'atc',
+                            type: 'line',
+                            equation: 'TFC / x + mc0 + (mcSlope / 2) * x',
+                            color: '#16A34A',
+                            strokeWidth: 2,
+                            label: 'ATC',
+                            domain: { min: 1, max: 'chartMaxQ' },
+                        },
+                        // Optimal point
+                        {
+                            id: 'optimum',
+                            type: 'point',
+                            x: 'Q_star',
+                            y: 'P',
+                            color: '#2563EB',
+                            size: 8,
+                            label: 'P = MC',
+                            droplines: { x: true, y: false },
+                        },
+                        // ATC at optimum
+                        {
+                            id: 'atc-point',
+                            type: 'point',
+                            x: 'Q_star',
+                            y: 'ATC_star',
+                            color: '#16A34A',
+                            droplines: { y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'q-label',
+                            text: 'Q* = ${Q_star:.1f}',
+                            x: 'Q_star',
+                            y: 'chartMaxP * 0.1',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'profit-label',
+                            text: 'π = $${profit:.2f}',
+                            x: 'Q_star / 2',
+                            y: '(P + ATC_star) / 2',
+                            color: 'profit > 0 ? "#16A34A" : "#DC2626"',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Perfect Competition - Long Run
+ *
+ * Shows long-run equilibrium with zero economic profit,
+ * where P = minimum ATC and firms produce at efficient scale.
+ */
+const perfectCompetitionLongRun = {
+    id: 'perfect_competition_long_run',
+    name: 'Perfect Competition - Long Run',
+    description: 'Long-run equilibrium with free entry/exit. Price equals minimum ATC, economic profit is zero, and firms produce at efficient scale.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['perfect competition', 'long run', 'zero profit', 'efficient scale'],
+    parameters: {
+        minATC: {
+            type: 'number',
+            default: 10,
+            min: 5,
+            max: 20,
+            description: 'Minimum ATC (long-run equilibrium price)',
+        },
+        efficientScale: {
+            type: 'number',
+            default: 10,
+            min: 5,
+            max: 20,
+            description: 'Efficient scale (output at min ATC)',
+        },
+        atcCurvature: {
+            type: 'number',
+            default: 0.1,
+            min: 0.05,
+            max: 0.3,
+            description: 'ATC curve curvature parameter',
+        },
+    },
+    generate: (params) => {
+        const minATC = params.minATC ?? 10;
+        const Q_eff = params.efficientScale ?? 10;
+        const a = params.atcCurvature ?? 0.1;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Perfect Competition - Long Run',
+                description: 'Zero profit equilibrium',
+            },
+            parameters: {
+                minATC: { value: minATC, label: 'Min ATC (P*)', min: 5, max: 20 },
+                Q_eff: { value: Q_eff, label: 'Efficient Scale', min: 5, max: 20 },
+                a: { value: a, label: 'ATC Curvature', min: 0.05, max: 0.3, step: 0.01 },
+                // Long-run price = min ATC
+                P_lr: { expression: 'minATC', label: 'LR Price', readonly: true },
+                // ATC at efficient scale
+                ATC_eff: { expression: 'minATC', label: 'ATC at Q*', readonly: true },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_eff * 2.5', hidden: true },
+                chartMaxP: { expression: 'minATC * 2', hidden: true },
+                // Profit at LR equilibrium
+                profit: { value: 0, label: 'Economic Profit', readonly: true },
+            },
+            charts: [
+                {
+                    id: 'firm',
+                    title: 'Representative Firm - Long Run Equilibrium',
+                    xAxis: { label: 'Quantity (q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price, Cost', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Demand = P (horizontal at min ATC)
+                        {
+                            id: 'demand',
+                            type: 'horizontalLine',
+                            y: 'P_lr',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'D = MR = P*',
+                        },
+                        // U-shaped ATC: ATC = minATC + a(Q - Q_eff)²
+                        {
+                            id: 'atc',
+                            type: 'line',
+                            equation: 'minATC + a * ((x - Q_eff) ^ 2)',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'LRAC',
+                            domain: { min: 1, max: 'chartMaxQ' },
+                        },
+                        // MC curve (derivative of TC): MC = minATC + 2a(Q - Q_eff) + 2a*Q_eff
+                        // Simplified: passes through min ATC at Q_eff
+                        {
+                            id: 'mc',
+                            type: 'line',
+                            equation: 'minATC + 2 * a * (x - Q_eff)',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC',
+                            domain: { min: 1, max: 'chartMaxQ' },
+                        },
+                        // Efficient scale point
+                        {
+                            id: 'efficient-point',
+                            type: 'point',
+                            x: 'Q_eff',
+                            y: 'minATC',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Efficient Scale',
+                            droplines: { x: true, y: true },
+                        },
+                        // MC = ATC intersection
+                        {
+                            id: 'mc-atc-intersect',
+                            type: 'point',
+                            x: 'Q_eff',
+                            y: 'minATC',
+                            color: '#DC2626',
+                            size: 6,
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'zero-profit',
+                            text: 'Zero Economic Profit',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.85',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'equilibrium-label',
+                            text: 'P* = min ATC = $${minATC}',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.75',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'scale-label',
+                            text: 'Q* = ${Q_eff} (efficient scale)',
+                            x: 'Q_eff + 1',
+                            y: 'minATC * 0.7',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Monopoly - Basic
+ *
+ * Shows monopolist facing downward-sloping demand,
+ * MR curve with twice the slope, and profit maximization where MR = MC.
+ */
+const monopolyBasic = {
+    id: 'monopoly_basic',
+    name: 'Monopoly - Profit Maximization',
+    description: 'Monopolist profit maximization where MR = MC. Shows downward-sloping demand, MR with twice the slope, optimal quantity and price, and monopoly profit.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['monopoly', 'MR=MC', 'market power', 'profit maximization'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            min: 50,
+            max: 200,
+            description: 'Demand curve intercept (choke price)',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 2,
+            min: 0.5,
+            max: 5,
+            description: 'Demand curve slope',
+        },
+        mcConstant: {
+            type: 'number',
+            default: 20,
+            min: 5,
+            max: 50,
+            description: 'Marginal cost (constant)',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 2;
+        const MC = params.mcConstant ?? 20;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Monopoly Profit Maximization',
+                description: 'MR = MC optimization',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 5, step: 0.1 },
+                MC: { value: MC, label: 'Marginal Cost', min: 5, max: 50 },
+                // Demand: P = a - bQ, MR = a - 2bQ
+                // Optimal Q where MR = MC: a - 2bQ = MC => Q* = (a - MC) / (2b)
+                Q_m: { expression: '(a - MC) / (2 * b)', label: 'Q_m', readonly: true },
+                // Monopoly price: P = a - bQ*
+                P_m: { expression: 'a - b * Q_m', label: 'P_m', readonly: true },
+                // MR at optimal quantity
+                MR_star: { expression: 'a - 2 * b * Q_m', label: 'MR*', readonly: true },
+                // Revenue and cost
+                TR: { expression: 'P_m * Q_m', label: 'Total Revenue', readonly: true },
+                TC: { expression: 'MC * Q_m', label: 'Total Cost', readonly: true },
+                profit: { expression: 'TR - TC', label: 'Profit', readonly: true },
+                // Competitive outcome for comparison
+                Q_c: { expression: '(a - MC) / b', hidden: true },
+                P_c: { expression: 'MC', hidden: true },
+                // Markup
+                markup: { expression: '(P_m - MC) / P_m', label: 'Lerner Index', readonly: true },
+                // Chart bounds
+                chartMaxQ: { expression: 'a / b * 1.1', hidden: true },
+                chartMaxP: { expression: 'a * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Monopoly: MR = MC',
+                    xAxis: { label: 'Quantity (Q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price, Cost', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Profit rectangle
+                        {
+                            id: 'profit-area',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'MC',
+                            x2: 'Q_m',
+                            y2: 'P_m',
+                            fill: '#22C55E',
+                            opacity: 0.3,
+                            label: 'Monopoly Profit',
+                        },
+                        // Demand curve
+                        {
+                            id: 'demand',
+                            type: 'line',
+                            equation: 'a - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand (AR)',
+                            domain: { min: 0, max: 'a / b' },
+                        },
+                        // MR curve (twice the slope)
+                        {
+                            id: 'mr',
+                            type: 'line',
+                            equation: 'a - 2 * b * x',
+                            color: '#7C3AED',
+                            strokeWidth: 3,
+                            label: 'MR',
+                            domain: { min: 0, max: 'a / (2 * b)' },
+                        },
+                        // MC curve (horizontal)
+                        {
+                            id: 'mc',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC',
+                        },
+                        // Optimal quantity point on MR
+                        {
+                            id: 'mr-mc-intersect',
+                            type: 'point',
+                            x: 'Q_m',
+                            y: 'MC',
+                            color: '#7C3AED',
+                            size: 8,
+                            label: 'MR = MC',
+                        },
+                        // Price point on demand
+                        {
+                            id: 'price-point',
+                            type: 'point',
+                            x: 'Q_m',
+                            y: 'P_m',
+                            color: '#2563EB',
+                            size: 8,
+                            label: 'P_m',
+                            droplines: { x: true, y: true },
+                        },
+                        // Vertical line from Q_m to demand
+                        {
+                            id: 'q-line',
+                            type: 'verticalLine',
+                            x: 'Q_m',
+                            color: '#6B7280',
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'P_m' },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'q-label',
+                            text: 'Q_m = ${Q_m:.1f}',
+                            x: 'Q_m + chartMaxQ * 0.05',
+                            y: 'chartMaxP * 0.15',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'p-label',
+                            text: 'P_m = $${P_m:.1f}',
+                            x: 'chartMaxQ * 0.05',
+                            y: 'P_m + chartMaxP * 0.03',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'profit-label',
+                            text: 'π = $${profit:.0f}',
+                            x: 'Q_m / 2',
+                            y: '(P_m + MC) / 2',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'markup-label',
+                            text: 'Lerner Index = ${markup:.2f}',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.9',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Monopoly - Deadweight Loss
+ *
+ * Compares monopoly outcome with competitive outcome,
+ * showing the deadweight loss from monopoly pricing.
+ */
+const monopolyDeadweightLoss = {
+    id: 'monopoly_deadweight_loss',
+    name: 'Monopoly - Deadweight Loss',
+    description: 'Welfare analysis comparing monopoly to perfect competition. Shows deadweight loss triangle, consumer surplus, and producer surplus under both market structures.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['monopoly', 'deadweight loss', 'welfare', 'efficiency', 'consumer surplus'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            description: 'Demand intercept',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 2,
+            description: 'Demand slope',
+        },
+        marginalCost: {
+            type: 'number',
+            default: 20,
+            description: 'Constant marginal cost',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 2;
+        const MC = params.marginalCost ?? 20;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Monopoly Deadweight Loss',
+                description: 'Welfare comparison with perfect competition',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 5, step: 0.1 },
+                MC: { value: MC, label: 'Marginal Cost', min: 5, max: 50 },
+                // Monopoly outcome
+                Q_m: { expression: '(a - MC) / (2 * b)', label: 'Q_m', readonly: true },
+                P_m: { expression: 'a - b * Q_m', label: 'P_m', readonly: true },
+                // Competitive outcome
+                Q_c: { expression: '(a - MC) / b', label: 'Q_c', readonly: true },
+                P_c: { expression: 'MC', label: 'P_c', readonly: true },
+                // Consumer Surplus under monopoly: (1/2)(a - P_m)(Q_m)
+                CS_m: { expression: '0.5 * (a - P_m) * Q_m', label: 'CS (monopoly)', readonly: true },
+                // Producer Surplus under monopoly: (P_m - MC) * Q_m
+                PS_m: { expression: '(P_m - MC) * Q_m', label: 'PS (monopoly)', readonly: true },
+                // Consumer Surplus under competition: (1/2)(a - MC)(Q_c)
+                CS_c: {
+                    expression: '0.5 * (a - MC) * Q_c',
+                    label: 'CS (competitive)',
+                    readonly: true,
+                },
+                // Total Surplus comparison
+                TS_m: { expression: 'CS_m + PS_m', label: 'TS (monopoly)', readonly: true },
+                TS_c: { expression: 'CS_c', label: 'TS (competitive)', readonly: true },
+                // Deadweight Loss: (1/2)(P_m - MC)(Q_c - Q_m)
+                DWL: {
+                    expression: '0.5 * (P_m - MC) * (Q_c - Q_m)',
+                    label: 'Deadweight Loss',
+                    readonly: true,
+                },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_c * 1.2', hidden: true },
+                chartMaxP: { expression: 'a * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Monopoly vs Perfect Competition',
+                    xAxis: { label: 'Quantity (Q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Consumer Surplus under monopoly
+                        {
+                            id: 'cs-monopoly',
+                            type: 'area',
+                            topBoundary: 'a',
+                            bottomBoundary: 'demand',
+                            leftBoundary: '0',
+                            rightBoundary: 'Q_m',
+                            color: '#3B82F6',
+                            opacity: 0.3,
+                            label: 'CS',
+                        },
+                        // Producer Surplus under monopoly
+                        {
+                            id: 'ps-monopoly',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'MC',
+                            x2: 'Q_m',
+                            y2: 'P_m',
+                            fill: '#22C55E',
+                            opacity: 0.3,
+                            label: 'PS',
+                        },
+                        // Deadweight Loss triangle
+                        {
+                            id: 'dwl',
+                            type: 'polygon',
+                            points: [
+                                { x: 'Q_m', y: 'P_m' },
+                                { x: 'Q_m', y: 'MC' },
+                                { x: 'Q_c', y: 'MC' },
+                            ],
+                            fill: '#EF4444',
+                            opacity: 0.4,
+                            label: 'DWL',
+                        },
+                        // Demand curve
+                        {
+                            id: 'demand',
+                            type: 'line',
+                            equation: 'a - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand',
+                            domain: { min: 0, max: 'a / b' },
+                        },
+                        // MR curve
+                        {
+                            id: 'mr',
+                            type: 'line',
+                            equation: 'a - 2 * b * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'MR',
+                            domain: { min: 0, max: 'a / (2 * b)' },
+                        },
+                        // MC curve
+                        {
+                            id: 'mc',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC = P_c',
+                        },
+                        // Monopoly point
+                        {
+                            id: 'monopoly-point',
+                            type: 'point',
+                            x: 'Q_m',
+                            y: 'P_m',
+                            color: '#7C3AED',
+                            size: 8,
+                            label: 'Monopoly',
+                            droplines: { x: true, y: true },
+                        },
+                        // Competitive point
+                        {
+                            id: 'competitive-point',
+                            type: 'point',
+                            x: 'Q_c',
+                            y: 'P_c',
+                            color: '#16A34A',
+                            size: 8,
+                            label: 'Competition',
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'dwl-label',
+                            text: 'DWL = $${DWL:.0f}',
+                            x: '(Q_m + Q_c) / 2',
+                            y: '(P_m + MC) / 2',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'comparison',
+                            text: 'Monopoly: Q=${Q_m:.0f}, P=$${P_m:.0f}',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.9',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'competition',
+                            text: 'Competition: Q=${Q_c:.0f}, P=$${P_c:.0f}',
+                            x: 'chartMaxQ * 0.6',
+                            y: 'chartMaxP * 0.82',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * First-Degree Price Discrimination
+ *
+ * Perfect price discrimination where monopolist captures all consumer surplus.
+ */
+const priceDiscriminationFirst = {
+    id: 'price_discrimination_first_degree',
+    name: 'First-Degree Price Discrimination',
+    description: 'Perfect price discrimination where each unit is sold at consumer\'s maximum willingness to pay. Monopolist captures all consumer surplus; no deadweight loss.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['price discrimination', 'perfect discrimination', 'consumer surplus', 'monopoly'],
+    parameters: {
+        demandIntercept: {
+            type: 'number',
+            default: 100,
+            description: 'Demand intercept',
+        },
+        demandSlope: {
+            type: 'number',
+            default: 2,
+            description: 'Demand slope',
+        },
+        marginalCost: {
+            type: 'number',
+            default: 20,
+            description: 'Marginal cost',
+        },
+    },
+    generate: (params) => {
+        const a = params.demandIntercept ?? 100;
+        const b = params.demandSlope ?? 2;
+        const MC = params.marginalCost ?? 20;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'First-Degree Price Discrimination',
+                description: 'Perfect price discrimination',
+            },
+            parameters: {
+                a: { value: a, label: 'Demand Intercept', min: 50, max: 200 },
+                b: { value: b, label: 'Demand Slope', min: 0.5, max: 5, step: 0.1 },
+                MC: { value: MC, label: 'Marginal Cost', min: 5, max: 50 },
+                // Output equals competitive quantity (efficient)
+                Q_pd: { expression: '(a - MC) / b', label: 'Q (PD)', readonly: true },
+                // Under perfect PD, firm extracts all surplus
+                profit: {
+                    expression: '0.5 * (a - MC) * Q_pd',
+                    label: 'Profit (all surplus)',
+                    readonly: true,
+                },
+                // No CS under perfect PD
+                CS: { value: 0, label: 'Consumer Surplus', readonly: true },
+                // No DWL under perfect PD
+                DWL: { value: 0, label: 'Deadweight Loss', readonly: true },
+                // Compare to simple monopoly
+                Q_m: { expression: '(a - MC) / (2 * b)', hidden: true },
+                P_m: { expression: 'a - b * Q_m', hidden: true },
+                profit_m: { expression: '(P_m - MC) * Q_m', label: 'Simple Monopoly π', readonly: true },
+                // Chart bounds
+                chartMaxQ: { expression: 'Q_pd * 1.2', hidden: true },
+                chartMaxP: { expression: 'a * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'First-Degree Price Discrimination',
+                    xAxis: { label: 'Quantity (Q)', min: 0, max: 'chartMaxQ' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Producer captures all surplus
+                        {
+                            id: 'total-surplus',
+                            type: 'area',
+                            topBoundary: 'demand',
+                            bottomBoundary: 'MC',
+                            leftBoundary: '0',
+                            rightBoundary: 'Q_pd',
+                            color: '#22C55E',
+                            opacity: 0.4,
+                            label: 'Producer Surplus (all)',
+                        },
+                        // Demand curve
+                        {
+                            id: 'demand',
+                            type: 'line',
+                            equation: 'a - b * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Demand = MR',
+                            domain: { min: 0, max: 'a / b' },
+                        },
+                        // MC curve
+                        {
+                            id: 'mc',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 3,
+                            label: 'MC',
+                        },
+                        // Simple monopoly MR for comparison
+                        {
+                            id: 'mr-simple',
+                            type: 'line',
+                            equation: 'a - 2 * b * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            label: 'MR (simple monopoly)',
+                            domain: { min: 0, max: 'a / (2 * b)' },
+                        },
+                        // Efficient quantity
+                        {
+                            id: 'pd-point',
+                            type: 'point',
+                            x: 'Q_pd',
+                            y: 'MC',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Efficient Output',
+                            droplines: { x: true },
+                        },
+                        // Simple monopoly point for comparison
+                        {
+                            id: 'monopoly-point',
+                            type: 'point',
+                            x: 'Q_m',
+                            y: 'P_m',
+                            color: '#9CA3AF',
+                            size: 6,
+                            label: 'Simple Monopoly',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'key-result',
+                            text: 'MR = Demand (each unit priced individually)',
+                            x: 'chartMaxQ * 0.5',
+                            y: 'chartMaxP * 0.9',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'profit-label',
+                            text: 'π = $${profit:.0f} (all surplus)',
+                            x: 'Q_pd / 2',
+                            y: '(a + MC) / 2',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'efficiency',
+                            text: 'Efficient (no DWL)',
+                            x: 'Q_pd + 2',
+                            y: 'MC + (a - MC) * 0.3',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Third-Degree Price Discrimination
+ *
+ * Market segmentation with different prices for different groups.
+ */
+const priceDiscriminationThird = {
+    id: 'price_discrimination_third_degree',
+    name: 'Third-Degree Price Discrimination',
+    description: 'Market segmentation price discrimination. Different prices for different consumer groups based on demand elasticity. Higher price in less elastic market.',
+    category: 'market_structures',
+    level: 'undergraduate',
+    tags: ['price discrimination', 'market segmentation', 'elasticity', 'monopoly'],
+    parameters: {
+        demand1Intercept: {
+            type: 'number',
+            default: 100,
+            description: 'Market 1 demand intercept',
+        },
+        demand1Slope: {
+            type: 'number',
+            default: 1,
+            description: 'Market 1 demand slope (less elastic)',
+        },
+        demand2Intercept: {
+            type: 'number',
+            default: 80,
+            description: 'Market 2 demand intercept',
+        },
+        demand2Slope: {
+            type: 'number',
+            default: 2,
+            description: 'Market 2 demand slope (more elastic)',
+        },
+        marginalCost: {
+            type: 'number',
+            default: 20,
+            description: 'Common marginal cost',
+        },
+    },
+    generate: (params) => {
+        const a1 = params.demand1Intercept ?? 100;
+        const b1 = params.demand1Slope ?? 1;
+        const a2 = params.demand2Intercept ?? 80;
+        const b2 = params.demand2Slope ?? 2;
+        const MC = params.marginalCost ?? 20;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Third-Degree Price Discrimination',
+                description: 'Market segmentation',
+            },
+            parameters: {
+                a1: { value: a1, label: 'Market 1 Intercept', min: 50, max: 150 },
+                b1: { value: b1, label: 'Market 1 Slope', min: 0.5, max: 3, step: 0.1 },
+                a2: { value: a2, label: 'Market 2 Intercept', min: 40, max: 120 },
+                b2: { value: b2, label: 'Market 2 Slope', min: 0.5, max: 4, step: 0.1 },
+                MC: { value: MC, label: 'Marginal Cost', min: 5, max: 40 },
+                // Market 1: MR1 = a1 - 2*b1*Q1 = MC => Q1 = (a1 - MC)/(2*b1)
+                Q1: { expression: '(a1 - MC) / (2 * b1)', label: 'Q₁', readonly: true },
+                P1: { expression: 'a1 - b1 * Q1', label: 'P₁', readonly: true },
+                // Market 2: MR2 = a2 - 2*b2*Q2 = MC => Q2 = (a2 - MC)/(2*b2)
+                Q2: { expression: '(a2 - MC) / (2 * b2)', label: 'Q₂', readonly: true },
+                P2: { expression: 'a2 - b2 * Q2', label: 'P₂', readonly: true },
+                // Profits
+                profit1: { expression: '(P1 - MC) * Q1', label: 'π₁', readonly: true },
+                profit2: { expression: '(P2 - MC) * Q2', label: 'π₂', readonly: true },
+                totalProfit: { expression: 'profit1 + profit2', label: 'Total π', readonly: true },
+                // Elasticities at optimal points
+                Ed1: { expression: '-1 * (1 / b1) * (P1 / Q1)', label: 'Ed₁', readonly: true },
+                Ed2: { expression: '-1 * (1 / b2) * (P2 / Q2)', label: 'Ed₂', readonly: true },
+                // Chart bounds
+                chartMaxQ1: { expression: 'a1 / b1 * 0.7', hidden: true },
+                chartMaxQ2: { expression: 'a2 / b2 * 0.7', hidden: true },
+                chartMaxP: { expression: 'max(a1, a2) * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'market1',
+                    title: 'Market 1 (Less Elastic)',
+                    xAxis: { label: 'Q₁', min: 0, max: 'chartMaxQ1' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Profit area
+                        {
+                            id: 'profit1',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'MC',
+                            x2: 'Q1',
+                            y2: 'P1',
+                            fill: '#22C55E',
+                            opacity: 0.3,
+                            label: 'Profit',
+                        },
+                        // Demand 1
+                        {
+                            id: 'demand1',
+                            type: 'line',
+                            equation: 'a1 - b1 * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'D₁',
+                            domain: { min: 0, max: 'a1 / b1' },
+                        },
+                        // MR1
+                        {
+                            id: 'mr1',
+                            type: 'line',
+                            equation: 'a1 - 2 * b1 * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR₁',
+                            domain: { min: 0, max: 'a1 / (2 * b1)' },
+                        },
+                        // MC
+                        {
+                            id: 'mc1',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'MC',
+                        },
+                        // Optimal point
+                        {
+                            id: 'opt1',
+                            type: 'point',
+                            x: 'Q1',
+                            y: 'P1',
+                            color: '#2563EB',
+                            size: 8,
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'price1-label',
+                            text: 'P₁ = $${P1:.1f}',
+                            x: 'Q1 + chartMaxQ1 * 0.1',
+                            y: 'P1',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'ed1-label',
+                            text: 'Ed₁ = ${Ed1:.2f}',
+                            x: 'chartMaxQ1 * 0.6',
+                            y: 'chartMaxP * 0.85',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+                {
+                    id: 'market2',
+                    title: 'Market 2 (More Elastic)',
+                    xAxis: { label: 'Q₂', min: 0, max: 'chartMaxQ2' },
+                    yAxis: { label: 'Price', min: 0, max: 'chartMaxP' },
+                    elements: [
+                        // Profit area
+                        {
+                            id: 'profit2',
+                            type: 'rectangle',
+                            x1: 0,
+                            y1: 'MC',
+                            x2: 'Q2',
+                            y2: 'P2',
+                            fill: '#22C55E',
+                            opacity: 0.3,
+                            label: 'Profit',
+                        },
+                        // Demand 2
+                        {
+                            id: 'demand2',
+                            type: 'line',
+                            equation: 'a2 - b2 * x',
+                            color: '#F59E0B',
+                            strokeWidth: 3,
+                            label: 'D₂',
+                            domain: { min: 0, max: 'a2 / b2' },
+                        },
+                        // MR2
+                        {
+                            id: 'mr2',
+                            type: 'line',
+                            equation: 'a2 - 2 * b2 * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            label: 'MR₂',
+                            domain: { min: 0, max: 'a2 / (2 * b2)' },
+                        },
+                        // MC
+                        {
+                            id: 'mc2',
+                            type: 'horizontalLine',
+                            y: 'MC',
+                            color: '#DC2626',
+                            strokeWidth: 2,
+                            label: 'MC',
+                        },
+                        // Optimal point
+                        {
+                            id: 'opt2',
+                            type: 'point',
+                            x: 'Q2',
+                            y: 'P2',
+                            color: '#F59E0B',
+                            size: 8,
+                            droplines: { x: true, y: true },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'price2-label',
+                            text: 'P₂ = $${P2:.1f}',
+                            x: 'Q2 + chartMaxQ2 * 0.1',
+                            y: 'P2',
+                            color: '#F59E0B',
+                        },
+                        {
+                            id: 'ed2-label',
+                            text: 'Ed₂ = ${Ed2:.2f}',
+                            x: 'chartMaxQ2 * 0.6',
+                            y: 'chartMaxP * 0.85',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export const marketStructuresTemplates = [
+    perfectCompetitionShortRun,
+    perfectCompetitionLongRun,
+    monopolyBasic,
+    monopolyDeadweightLoss,
+    priceDiscriminationFirst,
+    priceDiscriminationThird,
+];
+//# sourceMappingURL=marketStructures.js.map