equilibria-mcp-server 1.0.0

package/dist/templates/producer.js

@@ -0,0 +1,979 @@
+/**
+ * Producer Theory Templates
+ *
+ * Templates for producer theory models including isoquants, isocosts,
+ * cost minimization, and returns to scale analysis.
+ *
+ * Phase 3.3: Producer Theory
+ */
+// ============================================================================
+// PHASE 3.3: PRODUCER THEORY
+// ============================================================================
+/**
+ * Cobb-Douglas Isoquants
+ *
+ * Production function: Q = A * L^α * K^β
+ * Isoquants show combinations of labor (L) and capital (K) that produce same output.
+ */
+const isoquantsCobbDouglas = {
+    id: 'isoquants_cobb_douglas',
+    name: 'Cobb-Douglas Isoquants',
+    description: 'Production isoquants from Cobb-Douglas production function Q = A·L^α·K^β. Shows diminishing MRTS along each isoquant.',
+    category: 'production',
+    level: 'undergraduate',
+    tags: ['isoquants', 'production function', 'Cobb-Douglas', 'MRTS', 'producer theory'],
+    parameters: {
+        productivity: {
+            type: 'number',
+            default: 1,
+            min: 0.5,
+            max: 3,
+            description: 'Total factor productivity (A)',
+        },
+        alphaLabor: {
+            type: 'number',
+            default: 0.5,
+            min: 0.1,
+            max: 0.9,
+            description: 'Output elasticity of labor (α)',
+        },
+        betaCapital: {
+            type: 'number',
+            default: 0.5,
+            min: 0.1,
+            max: 0.9,
+            description: 'Output elasticity of capital (β)',
+        },
+        outputLevel: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 50,
+            description: 'Output level for main isoquant',
+        },
+    },
+    generate: (params) => {
+        const A = params.productivity ?? 1;
+        const alpha = params.alphaLabor ?? 0.5;
+        const beta = params.betaCapital ?? 0.5;
+        const Q = params.outputLevel ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Cobb-Douglas Isoquants',
+                description: 'Q = A·L^α·K^β',
+            },
+            parameters: {
+                A: { value: A, label: 'TFP (A)', min: 0.5, max: 3, step: 0.1 },
+                alpha: { value: alpha, label: 'α (labor)', min: 0.1, max: 0.9, step: 0.05 },
+                beta: { value: beta, label: 'β (capital)', min: 0.1, max: 0.9, step: 0.05 },
+                Q: { value: Q, label: 'Output Level', min: 1, max: 50 },
+                Q_low: { expression: 'Q * 0.6', hidden: true },
+                Q_high: { expression: 'Q * 1.4', hidden: true },
+                // Returns to scale
+                rts: { expression: 'alpha + beta', label: 'α + β (RTS)', readonly: true },
+                // Current point on isoquant
+                pointL: { value: Q ** (1 / (alpha + beta)), label: 'Labor (L)', min: 1, max: 30 },
+                pointK: {
+                    expression: '(Q / (A * (pointL ^ alpha))) ^ (1 / beta)',
+                    label: 'Capital (K)',
+                    readonly: true,
+                },
+                // MRTS at current point: MRTS = (α/β) * (K/L)
+                MRTS: {
+                    expression: '(alpha / beta) * (pointK / pointL)',
+                    label: 'MRTS',
+                    readonly: true,
+                },
+                // Chart bounds
+                chartMax: { expression: 'max(pointL, pointK) * 2.5', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Production Isoquants',
+                    xAxis: { label: 'Labor (L)', min: 0.5, max: 'chartMax' },
+                    yAxis: { label: 'Capital (K)', min: 0.5, max: 'chartMax' },
+                    elements: [
+                        // Lower output isoquant
+                        {
+                            id: 'isoquant-low',
+                            type: 'line',
+                            equation: '(Q_low / (A * (x ^ alpha))) ^ (1 / beta)',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q_low:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.95' },
+                        },
+                        // Main output isoquant
+                        {
+                            id: 'isoquant-main',
+                            type: 'line',
+                            equation: '(Q / (A * (x ^ alpha))) ^ (1 / beta)',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Q = ${Q:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.95' },
+                        },
+                        // Higher output isoquant
+                        {
+                            id: 'isoquant-high',
+                            type: 'line',
+                            equation: '(Q_high / (A * (x ^ alpha))) ^ (1 / beta)',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q_high:.1f}',
+                            domain: { min: 0.5, max: 'chartMax * 0.95' },
+                        },
+                        // Current point
+                        {
+                            id: 'current-point',
+                            type: 'point',
+                            x: 'pointL',
+                            y: 'pointK',
+                            color: '#16A34A',
+                            label: 'Current',
+                            droplines: { x: true, y: true },
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { pointL: 'x' } },
+                                constraints: { bounds: { minX: 1, maxX: 'chartMax * 0.8' } },
+                            },
+                        },
+                        // Tangent line showing MRTS
+                        {
+                            id: 'tangent',
+                            type: 'line',
+                            equation: 'pointK - MRTS * (x - pointL)',
+                            color: '#DC2626',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 'max(0.5, pointL - 5)', max: 'pointL + 5' },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'mrts-label',
+                            text: 'MRTS = ${MRTS:.2f}',
+                            x: 'pointL + chartMax * 0.08',
+                            y: 'pointK',
+                            color: '#DC2626',
+                        },
+                        {
+                            id: 'rts-label',
+                            text: 'α + β = ${rts:.2f}',
+                            x: 'chartMax * 0.7',
+                            y: 'chartMax * 0.9',
+                            color: '#6B7280',
+                        },
+                        {
+                            id: 'rts-type',
+                            text: '${rts > 1 ? "Increasing" : (rts < 1 ? "Decreasing" : "Constant")} RTS',
+                            x: 'chartMax * 0.7',
+                            y: 'chartMax * 0.82',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Isocost Lines
+ *
+ * Shows combinations of inputs that cost the same total amount.
+ * C = wL + rK  →  K = C/r - (w/r)L
+ */
+const isocostLines = {
+    id: 'isocost_lines',
+    name: 'Isocost Lines',
+    description: 'Isocost lines showing combinations of labor and capital with equal total cost. Slope = -w/r (negative wage-rental ratio).',
+    category: 'production',
+    level: 'undergraduate',
+    tags: ['isocost', 'input costs', 'wage', 'rental rate', 'producer theory'],
+    parameters: {
+        totalCost: {
+            type: 'number',
+            default: 100,
+            min: 20,
+            max: 300,
+            description: 'Total cost budget (C)',
+        },
+        wage: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 30,
+            description: 'Wage rate (w)',
+        },
+        rentalRate: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 30,
+            description: 'Rental rate of capital (r)',
+        },
+    },
+    generate: (params) => {
+        const C = params.totalCost ?? 100;
+        const w = params.wage ?? 10;
+        const r = params.rentalRate ?? 10;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Isocost Lines',
+                description: 'C = wL + rK',
+            },
+            parameters: {
+                C: { value: C, label: 'Total Cost', min: 20, max: 300, step: 10 },
+                w: { value: w, label: 'Wage (w)', min: 1, max: 30 },
+                r: { value: r, label: 'Rental Rate (r)', min: 1, max: 30 },
+                C_low: { expression: 'C * 0.6', hidden: true },
+                C_high: { expression: 'C * 1.4', hidden: true },
+                // Intercepts
+                maxL: { expression: 'C / w', label: 'Max L', readonly: true },
+                maxK: { expression: 'C / r', label: 'Max K', readonly: true },
+                // Slope
+                slope: { expression: '-w / r', label: 'Slope (-w/r)', readonly: true },
+                // Chart bounds
+                chartMaxL: { expression: 'C_high / w * 1.1', hidden: true },
+                chartMaxK: { expression: 'C_high / r * 1.1', hidden: true },
+                // Example point on isocost
+                pointL: { value: C / (2 * w), label: 'Labor', min: 0, max: 'maxL' },
+                pointK: { expression: '(C - w * pointL) / r', label: 'Capital', readonly: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Isocost Lines: C = wL + rK',
+                    xAxis: { label: 'Labor (L)', min: 0, max: 'chartMaxL' },
+                    yAxis: { label: 'Capital (K)', min: 0, max: 'chartMaxK' },
+                    elements: [
+                        // Lower cost isocost
+                        {
+                            id: 'isocost-low',
+                            type: 'line',
+                            equation: 'C_low / r - (w / r) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'C = $${C_low:.0f}',
+                            domain: { min: 0, max: 'C_low / w' },
+                        },
+                        // Main isocost
+                        {
+                            id: 'isocost-main',
+                            type: 'line',
+                            equation: 'C / r - (w / r) * x',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'C = $${C:.0f}',
+                            domain: { min: 0, max: 'maxL' },
+                        },
+                        // Higher cost isocost
+                        {
+                            id: 'isocost-high',
+                            type: 'line',
+                            equation: 'C_high / r - (w / r) * x',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'C = $${C_high:.0f}',
+                            domain: { min: 0, max: 'C_high / w' },
+                        },
+                        // Intercept points
+                        {
+                            id: 'l-intercept',
+                            type: 'point',
+                            x: 'maxL',
+                            y: 0,
+                            color: '#7C3AED',
+                            label: 'C/w',
+                        },
+                        {
+                            id: 'k-intercept',
+                            type: 'point',
+                            x: 0,
+                            y: 'maxK',
+                            color: '#7C3AED',
+                            label: 'C/r',
+                        },
+                        // Current point
+                        {
+                            id: 'current',
+                            type: 'point',
+                            x: 'pointL',
+                            y: 'pointK',
+                            color: '#16A34A',
+                            label: 'Bundle',
+                            droplines: { x: true, y: true },
+                            draggable: true,
+                            dragConfig: {
+                                mode: 'expression',
+                                parameters: { expressions: { pointL: 'x' } },
+                                constraints: { bounds: { minX: 0, maxX: 'maxL' } },
+                            },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'slope-label',
+                            text: 'Slope = -w/r = ${slope:.2f}',
+                            x: 'maxL * 0.5',
+                            y: 'maxK * 0.7',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'cost-breakdown',
+                            text: 'wL = $${w * pointL:.0f}, rK = $${r * pointK:.0f}',
+                            x: 'chartMaxL * 0.6',
+                            y: 'chartMaxK * 0.9',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Cost Minimization
+ *
+ * Optimal input combination where isoquant is tangent to isocost.
+ * MRTS = w/r at the optimum.
+ */
+const costMinimization = {
+    id: 'cost_minimization',
+    name: 'Cost Minimization',
+    description: 'Optimal input mix where isoquant is tangent to isocost line. At optimum: MRTS = w/r (marginal rate of technical substitution equals input price ratio).',
+    category: 'production',
+    level: 'undergraduate',
+    tags: ['cost minimization', 'optimal inputs', 'MRTS', 'tangency', 'producer theory'],
+    parameters: {
+        outputTarget: {
+            type: 'number',
+            default: 10,
+            min: 5,
+            max: 30,
+            description: 'Target output level',
+        },
+        wage: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 30,
+            description: 'Wage rate (w)',
+        },
+        rentalRate: {
+            type: 'number',
+            default: 10,
+            min: 1,
+            max: 30,
+            description: 'Rental rate of capital (r)',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.5,
+            min: 0.2,
+            max: 0.8,
+            description: 'Labor elasticity (α)',
+        },
+    },
+    generate: (params) => {
+        const Q = params.outputTarget ?? 10;
+        const w = params.wage ?? 10;
+        const r = params.rentalRate ?? 10;
+        const alpha = params.alpha ?? 0.5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Cost Minimization',
+                description: 'Optimal input combination',
+            },
+            parameters: {
+                Q: { value: Q, label: 'Target Output', min: 5, max: 30 },
+                w: { value: w, label: 'Wage (w)', min: 1, max: 30 },
+                r: { value: r, label: 'Rental Rate (r)', min: 1, max: 30 },
+                alpha: { value: alpha, label: 'α', min: 0.2, max: 0.8, step: 0.05 },
+                beta: { expression: '1 - alpha', label: 'β', readonly: true },
+                // Optimal inputs (from cost minimization FOCs)
+                // L* = Q * (α/β * r/w)^β and K* = Q * (β/α * w/r)^α
+                optL: {
+                    expression: 'Q * ((alpha / (1 - alpha)) * (r / w)) ^ (1 - alpha)',
+                    label: 'Optimal L',
+                    readonly: true,
+                },
+                optK: {
+                    expression: 'Q * (((1 - alpha) / alpha) * (w / r)) ^ alpha',
+                    label: 'Optimal K',
+                    readonly: true,
+                },
+                // Minimum cost
+                minCost: {
+                    expression: 'w * optL + r * optK',
+                    label: 'Min Cost',
+                    readonly: true,
+                },
+                // MRTS at optimum
+                MRTS: {
+                    expression: '(alpha / (1 - alpha)) * (optK / optL)',
+                    label: 'MRTS',
+                    readonly: true,
+                },
+                priceRatio: { expression: 'w / r', label: 'w/r', readonly: true },
+                // Suboptimal cost line
+                higherCost: { expression: 'minCost * 1.3', hidden: true },
+                // Chart bounds
+                chartMaxL: { expression: 'higherCost / w * 1.1', hidden: true },
+                chartMaxK: { expression: 'higherCost / r * 1.1', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Cost Minimization: MRTS = w/r',
+                    xAxis: { label: 'Labor (L)', min: 0.5, max: 'chartMaxL' },
+                    yAxis: { label: 'Capital (K)', min: 0.5, max: 'chartMaxK' },
+                    elements: [
+                        // Higher cost isocost (tangent but suboptimal)
+                        {
+                            id: 'isocost-high',
+                            type: 'line',
+                            equation: 'higherCost / r - (w / r) * x',
+                            color: '#EF4444',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            label: 'C = $${higherCost:.0f}',
+                            domain: { min: 0, max: 'higherCost / w' },
+                        },
+                        // Minimum cost isocost
+                        {
+                            id: 'isocost-min',
+                            type: 'line',
+                            equation: 'minCost / r - (w / r) * x',
+                            color: '#16A34A',
+                            strokeWidth: 3,
+                            label: 'C* = $${minCost:.0f}',
+                            domain: { min: 0, max: 'minCost / w' },
+                        },
+                        // Isoquant
+                        {
+                            id: 'isoquant',
+                            type: 'line',
+                            equation: '(Q / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Q = ${Q}',
+                            domain: { min: 0.5, max: 'chartMaxL * 0.95' },
+                        },
+                        // Optimal point
+                        {
+                            id: 'optimum',
+                            type: 'point',
+                            x: 'optL',
+                            y: 'optK',
+                            color: '#16A34A',
+                            size: 10,
+                            label: 'Optimum',
+                            droplines: { x: true, y: true },
+                        },
+                        // Tangent line
+                        {
+                            id: 'tangent',
+                            type: 'line',
+                            equation: 'optK - priceRatio * (x - optL)',
+                            color: '#7C3AED',
+                            strokeWidth: 1,
+                            lineStyle: 'dotted',
+                            domain: { min: 'max(0.5, optL - 5)', max: 'optL + 5' },
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'opt-label',
+                            text: 'L* = ${optL:.2f}, K* = ${optK:.2f}',
+                            x: 'optL + chartMaxL * 0.05',
+                            y: 'optK + chartMaxK * 0.05',
+                            color: '#16A34A',
+                        },
+                        {
+                            id: 'tangency-label',
+                            text: 'MRTS = w/r = ${priceRatio:.2f}',
+                            x: 'chartMaxL * 0.6',
+                            y: 'chartMaxK * 0.9',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'cost-label',
+                            text: 'Minimum Cost = $${minCost:.2f}',
+                            x: 'chartMaxL * 0.6',
+                            y: 'chartMaxK * 0.82',
+                            color: '#16A34A',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Expansion Path
+ *
+ * Locus of cost-minimizing input combinations as output varies.
+ * For Cobb-Douglas, this is a ray through the origin.
+ */
+const expansionPath = {
+    id: 'expansion_path',
+    name: 'Expansion Path',
+    description: 'Long-run expansion path showing optimal input combinations as output scales. For Cobb-Douglas, the path is a ray through the origin with slope K/L = (β/α)(w/r).',
+    category: 'production',
+    level: 'undergraduate',
+    tags: ['expansion path', 'long-run', 'scaling', 'cost minimization', 'producer theory'],
+    parameters: {
+        wage: {
+            type: 'number',
+            default: 10,
+            description: 'Wage rate (w)',
+        },
+        rentalRate: {
+            type: 'number',
+            default: 10,
+            description: 'Rental rate of capital (r)',
+        },
+        alpha: {
+            type: 'number',
+            default: 0.6,
+            description: 'Labor elasticity (α)',
+        },
+        outputLow: {
+            type: 'number',
+            default: 5,
+            description: 'Low output level',
+        },
+        outputMid: {
+            type: 'number',
+            default: 10,
+            description: 'Medium output level',
+        },
+        outputHigh: {
+            type: 'number',
+            default: 15,
+            description: 'High output level',
+        },
+    },
+    generate: (params) => {
+        const w = params.wage ?? 10;
+        const r = params.rentalRate ?? 10;
+        const alpha = params.alpha ?? 0.6;
+        const Q_low = params.outputLow ?? 5;
+        const Q_mid = params.outputMid ?? 10;
+        const Q_high = params.outputHigh ?? 15;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Expansion Path',
+                description: 'Long-run optimal input combinations',
+            },
+            parameters: {
+                w: { value: w, label: 'Wage (w)', min: 1, max: 30 },
+                r: { value: r, label: 'Rental Rate (r)', min: 1, max: 30 },
+                alpha: { value: alpha, label: 'α', min: 0.2, max: 0.8, step: 0.05 },
+                beta: { expression: '1 - alpha', hidden: true },
+                Q_low: { value: Q_low, label: 'Q (low)', min: 1, max: 10 },
+                Q_mid: { value: Q_mid, label: 'Q (mid)', min: 5, max: 20 },
+                Q_high: { value: Q_high, label: 'Q (high)', min: 10, max: 30 },
+                // Expansion path slope: K/L = (β/α)(w/r)
+                expansionSlope: {
+                    expression: '((1 - alpha) / alpha) * (w / r)',
+                    label: 'K/L Ratio',
+                    readonly: true,
+                },
+                // Optimal inputs at each output
+                L_low: {
+                    expression: 'Q_low * ((alpha / (1 - alpha)) * (r / w)) ^ (1 - alpha)',
+                    hidden: true,
+                },
+                K_low: {
+                    expression: 'Q_low * (((1 - alpha) / alpha) * (w / r)) ^ alpha',
+                    hidden: true,
+                },
+                L_mid: {
+                    expression: 'Q_mid * ((alpha / (1 - alpha)) * (r / w)) ^ (1 - alpha)',
+                    hidden: true,
+                },
+                K_mid: {
+                    expression: 'Q_mid * (((1 - alpha) / alpha) * (w / r)) ^ alpha',
+                    hidden: true,
+                },
+                L_high: {
+                    expression: 'Q_high * ((alpha / (1 - alpha)) * (r / w)) ^ (1 - alpha)',
+                    hidden: true,
+                },
+                K_high: {
+                    expression: 'Q_high * (((1 - alpha) / alpha) * (w / r)) ^ alpha',
+                    hidden: true,
+                },
+                // Costs at each level
+                C_low: { expression: 'w * L_low + r * K_low', label: 'Cost (low)', readonly: true },
+                C_mid: { expression: 'w * L_mid + r * K_mid', label: 'Cost (mid)', readonly: true },
+                C_high: { expression: 'w * L_high + r * K_high', label: 'Cost (high)', readonly: true },
+                // Chart bounds
+                chartMaxL: { expression: 'L_high * 1.3', hidden: true },
+                chartMaxK: { expression: 'K_high * 1.3', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Expansion Path',
+                    xAxis: { label: 'Labor (L)', min: 0, max: 'chartMaxL' },
+                    yAxis: { label: 'Capital (K)', min: 0, max: 'chartMaxK' },
+                    elements: [
+                        // Expansion path (ray through origin)
+                        {
+                            id: 'expansion-path',
+                            type: 'line',
+                            equation: 'expansionSlope * x',
+                            color: '#7C3AED',
+                            strokeWidth: 3,
+                            label: 'Expansion Path',
+                            domain: { min: 0, max: 'chartMaxL' },
+                        },
+                        // Isoquants
+                        {
+                            id: 'isoquant-low',
+                            type: 'line',
+                            equation: '(Q_low / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#93C5FD',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q_low}',
+                            domain: { min: 0.3, max: 'chartMaxL * 0.95' },
+                        },
+                        {
+                            id: 'isoquant-mid',
+                            type: 'line',
+                            equation: '(Q_mid / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q_mid}',
+                            domain: { min: 0.3, max: 'chartMaxL * 0.95' },
+                        },
+                        {
+                            id: 'isoquant-high',
+                            type: 'line',
+                            equation: '(Q_high / (x ^ alpha)) ^ (1 / (1 - alpha))',
+                            color: '#1D4ED8',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q_high}',
+                            domain: { min: 0.3, max: 'chartMaxL * 0.95' },
+                        },
+                        // Isocost lines (tangent at optimal points)
+                        {
+                            id: 'isocost-low',
+                            type: 'line',
+                            equation: 'C_low / r - (w / r) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'C_low / w' },
+                        },
+                        {
+                            id: 'isocost-mid',
+                            type: 'line',
+                            equation: 'C_mid / r - (w / r) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'C_mid / w' },
+                        },
+                        {
+                            id: 'isocost-high',
+                            type: 'line',
+                            equation: 'C_high / r - (w / r) * x',
+                            color: '#9CA3AF',
+                            strokeWidth: 1,
+                            lineStyle: 'dashed',
+                            domain: { min: 0, max: 'C_high / w' },
+                        },
+                        // Optimal points
+                        {
+                            id: 'opt-low',
+                            type: 'point',
+                            x: 'L_low',
+                            y: 'K_low',
+                            color: '#16A34A',
+                            label: 'A',
+                        },
+                        {
+                            id: 'opt-mid',
+                            type: 'point',
+                            x: 'L_mid',
+                            y: 'K_mid',
+                            color: '#16A34A',
+                            size: 8,
+                            label: 'B',
+                        },
+                        {
+                            id: 'opt-high',
+                            type: 'point',
+                            x: 'L_high',
+                            y: 'K_high',
+                            color: '#16A34A',
+                            label: 'C',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'slope-label',
+                            text: 'K/L = (β/α)(w/r) = ${expansionSlope:.2f}',
+                            x: 'chartMaxL * 0.6',
+                            y: 'chartMaxK * 0.9',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'path-label',
+                            text: 'Expansion Path',
+                            x: 'L_high * 1.1',
+                            y: 'K_high * 1.1',
+                            color: '#7C3AED',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+/**
+ * Returns to Scale Visualization
+ *
+ * Shows increasing, constant, and decreasing returns to scale
+ * by comparing input scaling with output scaling.
+ */
+const returnsToScale = {
+    id: 'returns_to_scale',
+    name: 'Returns to Scale',
+    description: 'Visualizes returns to scale: when inputs double, output may more than double (IRS), exactly double (CRS), or less than double (DRS). Determined by α + β.',
+    category: 'production',
+    level: 'undergraduate',
+    tags: ['returns to scale', 'IRS', 'CRS', 'DRS', 'scaling', 'producer theory'],
+    parameters: {
+        alpha: {
+            type: 'number',
+            default: 0.6,
+            min: 0.1,
+            max: 0.9,
+            description: 'Labor elasticity (α)',
+        },
+        beta: {
+            type: 'number',
+            default: 0.6,
+            min: 0.1,
+            max: 0.9,
+            description: 'Capital elasticity (β)',
+        },
+        baseLabor: {
+            type: 'number',
+            default: 5,
+            description: 'Base labor input',
+        },
+        baseCapital: {
+            type: 'number',
+            default: 5,
+            description: 'Base capital input',
+        },
+    },
+    generate: (params) => {
+        const alpha = params.alpha ?? 0.6;
+        const beta = params.beta ?? 0.6;
+        const L0 = params.baseLabor ?? 5;
+        const K0 = params.baseCapital ?? 5;
+        return {
+            metadata: {
+                specVersion: '1.3',
+                title: 'Returns to Scale',
+                description: 'Q = L^α · K^β, RTS = α + β',
+            },
+            parameters: {
+                alpha: { value: alpha, label: 'α (labor)', min: 0.1, max: 0.9, step: 0.05 },
+                beta: { value: beta, label: 'β (capital)', min: 0.1, max: 0.9, step: 0.05 },
+                L0: { value: L0, label: 'Base L', min: 1, max: 20 },
+                K0: { value: K0, label: 'Base K', min: 1, max: 20 },
+                // Returns to scale parameter
+                rts: { expression: 'alpha + beta', label: 'α + β', readonly: true },
+                // Base output
+                Q0: { expression: '(L0 ^ alpha) * (K0 ^ beta)', label: 'Base Q', readonly: true },
+                // Scaled inputs (2x)
+                L1: { expression: '2 * L0', hidden: true },
+                K1: { expression: '2 * K0', hidden: true },
+                // Output with doubled inputs
+                Q1: { expression: '(L1 ^ alpha) * (K1 ^ beta)', label: 'Q (2x inputs)', readonly: true },
+                // Output ratio
+                outputRatio: { expression: 'Q1 / Q0', label: 'Q ratio', readonly: true },
+                // For the chart: scaling factor on x-axis, output on y-axis
+                chartMaxScale: { value: 3, hidden: true },
+                chartMaxQ: { expression: 'Q0 * (chartMaxScale ^ rts) * 1.1', hidden: true },
+                // Reference lines for different RTS
+                irsQ: { expression: 'Q0 * (2 ^ 1.2)', hidden: true },
+                crsQ: { expression: 'Q0 * 2', hidden: true },
+                drsQ: { expression: 'Q0 * (2 ^ 0.8)', hidden: true },
+            },
+            charts: [
+                {
+                    id: 'main',
+                    title: 'Returns to Scale: Output vs Input Scaling',
+                    xAxis: { label: 'Input Scale Factor (t)', min: 0.5, max: 'chartMaxScale' },
+                    yAxis: { label: 'Output Q(tL, tK)', min: 0, max: 'chartMaxQ' },
+                    elements: [
+                        // Actual RTS curve: Q = Q0 * t^(α+β)
+                        {
+                            id: 'rts-curve',
+                            type: 'line',
+                            equation: 'Q0 * (x ^ rts)',
+                            color: '#2563EB',
+                            strokeWidth: 3,
+                            label: 'Actual (α+β=${rts:.2f})',
+                        },
+                        // Reference: CRS (α+β = 1)
+                        {
+                            id: 'crs-reference',
+                            type: 'line',
+                            equation: 'Q0 * x',
+                            color: '#6B7280',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'CRS (α+β=1)',
+                        },
+                        // Base point (scale = 1)
+                        {
+                            id: 'base-point',
+                            type: 'point',
+                            x: 1,
+                            y: 'Q0',
+                            color: '#16A34A',
+                            label: 'Base',
+                            droplines: { x: true, y: true },
+                        },
+                        // Doubled point (scale = 2)
+                        {
+                            id: 'doubled-point',
+                            type: 'point',
+                            x: 2,
+                            y: 'Q1',
+                            color: '#7C3AED',
+                            label: '2x inputs',
+                            droplines: { x: true, y: true },
+                        },
+                        // CRS reference point
+                        {
+                            id: 'crs-point',
+                            type: 'point',
+                            x: 2,
+                            y: 'crsQ',
+                            color: '#6B7280',
+                            size: 5,
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'rts-type',
+                            text: '${rts > 1 ? "Increasing" : (rts < 1 ? "Decreasing" : "Constant")} Returns to Scale',
+                            x: 'chartMaxScale * 0.5',
+                            y: 'chartMaxQ * 0.9',
+                            color: '#2563EB',
+                        },
+                        {
+                            id: 'ratio-label',
+                            text: 'When inputs double: Q × ${outputRatio:.2f}',
+                            x: 'chartMaxScale * 0.5',
+                            y: 'chartMaxQ * 0.8',
+                            color: '#7C3AED',
+                        },
+                        {
+                            id: 'formula',
+                            text: 'Q(tL,tK) = t^(α+β) · Q(L,K)',
+                            x: 'chartMaxScale * 0.5',
+                            y: 'chartMaxQ * 0.15',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+                {
+                    id: 'isoquant-map',
+                    title: 'Isoquant Spacing',
+                    xAxis: { label: 'Labor (L)', min: 0, max: 'L1 * 1.3' },
+                    yAxis: { label: 'Capital (K)', min: 0, max: 'K1 * 1.3' },
+                    elements: [
+                        // Ray from origin
+                        {
+                            id: 'ray',
+                            type: 'line',
+                            equation: '(K0 / L0) * x',
+                            color: '#7C3AED',
+                            strokeWidth: 2,
+                            lineStyle: 'dashed',
+                            label: 'Scaling Ray',
+                        },
+                        // Base isoquant
+                        {
+                            id: 'isoquant-base',
+                            type: 'line',
+                            equation: '(Q0 / (x ^ alpha)) ^ (1 / beta)',
+                            color: '#16A34A',
+                            strokeWidth: 2,
+                            label: 'Q = ${Q0:.1f}',
+                            domain: { min: 0.5, max: 'L1 * 1.2' },
+                        },
+                        // Double output isoquant
+                        {
+                            id: 'isoquant-double',
+                            type: 'line',
+                            equation: '(crsQ / (x ^ alpha)) ^ (1 / beta)',
+                            color: '#2563EB',
+                            strokeWidth: 2,
+                            label: 'Q = ${crsQ:.1f}',
+                            domain: { min: 0.5, max: 'L1 * 1.2' },
+                        },
+                        // Base point
+                        {
+                            id: 'base',
+                            type: 'point',
+                            x: 'L0',
+                            y: 'K0',
+                            color: '#16A34A',
+                            label: '(L₀, K₀)',
+                        },
+                        // Doubled inputs point
+                        {
+                            id: 'doubled',
+                            type: 'point',
+                            x: 'L1',
+                            y: 'K1',
+                            color: '#7C3AED',
+                            label: '(2L₀, 2K₀)',
+                        },
+                    ],
+                    annotations: [
+                        {
+                            id: 'spacing-note',
+                            text: '${rts > 1 ? "Closer spacing = IRS" : (rts < 1 ? "Wider spacing = DRS" : "Equal spacing = CRS")}',
+                            x: 'L1 * 0.8',
+                            y: 'K1 * 1.2',
+                            color: '#6B7280',
+                        },
+                    ],
+                },
+            ],
+        };
+    },
+};
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export const producerTheoryTemplates = [
+    isoquantsCobbDouglas,
+    isocostLines,
+    costMinimization,
+    expansionPath,
+    returnsToScale,
+];
+//# sourceMappingURL=producer.js.map