scax-engine 0.1.8 → 0.2.0-beta.1

package/dist/scax-engine.umd.js

@@ -6741,119 +6741,6 @@
 
 	_m.set( -1, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 );
 
-	/**
-	 * 2D affine 왜곡 추정 전용 클래스입니다.
-	 * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
-	 */
-	class Affine {
-	    constructor() {
-	        this.lastResult = null;
-	        this.lastPairs = [];
-	    }
-	    estimate(pairs) {
-	        const inputPairs = Array.isArray(pairs) ? pairs : [];
-	        this.lastPairs = inputPairs;
-	        const affine = this.fitAffine2D(inputPairs);
-	        if (!affine) {
-	            this.lastResult = null;
-	            return null;
-	        }
-	        let residualSumPct = 0;
-	        let residualCount = 0;
-	        let residualMaxPct = 0;
-	        const residuals = [];
-	        for (const pair of inputPairs) {
-	            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
-	            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
-	            const rx = pair.tx - px;
-	            const ry = pair.ty - py;
-	            const magnitude = Math.hypot(rx, ry);
-	            if (magnitude < 1e-4)
-	                continue;
-	            const radiusRef = Math.hypot(px, py);
-	            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
-	            residualSumPct += pct;
-	            residualCount += 1;
-	            residualMaxPct = Math.max(residualMaxPct, pct);
-	            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
-	        }
-	        const result = {
-	            ...affine,
-	            count: inputPairs.length,
-	            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
-	            residualMaxPct,
-	            residuals,
-	        };
-	        this.lastResult = result;
-	        return result;
-	    }
-	    /**
-	     * 마지막 affine 추정 결과를 반환합니다.
-	     */
-	    getLastResult() {
-	        return this.lastResult;
-	    }
-	    /**
-	     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
-	     */
-	    getLastPairs() {
-	        return [...this.lastPairs];
-	    }
-	    fitAffine2D(pairs) {
-	        if (!Array.isArray(pairs) || pairs.length < 4)
-	            return null;
-	        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
-	        const atb = Array(6).fill(0);
-	        const accumulate = (row, rhs) => {
-	            for (let i = 0; i < 6; i += 1) {
-	                atb[i] += row[i] * rhs;
-	                for (let j = 0; j < 6; j += 1)
-	                    ata[i][j] += row[i] * row[j];
-	            }
-	        };
-	        for (const pair of pairs) {
-	            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
-	            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
-	        }
-	        const n = 6;
-	        const aug = ata.map((row, index) => [...row, atb[index]]);
-	        for (let col = 0; col < n; col += 1) {
-	            let pivot = col;
-	            for (let row = col + 1; row < n; row += 1) {
-	                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
-	                    pivot = row;
-	            }
-	            if (Math.abs(aug[pivot][col]) < 1e-10)
-	                return null;
-	            if (pivot !== col) {
-	                const temp = aug[col];
-	                aug[col] = aug[pivot];
-	                aug[pivot] = temp;
-	            }
-	            const divider = aug[col][col];
-	            for (let j = col; j <= n; j += 1)
-	                aug[col][j] /= divider;
-	            for (let row = 0; row < n; row += 1) {
-	                if (row === col)
-	                    continue;
-	                const factor = aug[row][col];
-	                if (Math.abs(factor) < 1e-12)
-	                    continue;
-	                for (let j = col; j <= n; j += 1)
-	                    aug[row][j] -= factor * aug[col][j];
-	            }
-	        }
-	        return {
-	            a: aug[0][n],
-	            b: aug[1][n],
-	            c: aug[2][n],
-	            d: aug[3][n],
-	            e: aug[4][n],
-	            f: aug[5][n],
-	        };
-	    }
-	}
-
 	/**
 	 * 프라운호퍼 파장과 색상
 	 */
@@ -7130,9 +7017,125 @@
 	    }
 	}
 
+	/**
+	 * 2D affine 왜곡 추정 전용 클래스입니다.
+	 * [x'; y'] = [[a b c], [d e f]] * [x y 1]^T 형태를 최소자승으로 적합합니다.
+	 */
+	class Affine {
+	    constructor() {
+	        this.lastResult = null;
+	        this.lastPairs = [];
+	    }
+	    estimate(pairs) {
+	        const inputPairs = Array.isArray(pairs) ? pairs : [];
+	        this.lastPairs = inputPairs;
+	        const affine = this.fitAffine2D(inputPairs);
+	        if (!affine) {
+	            this.lastResult = null;
+	            return null;
+	        }
+	        let residualSumPct = 0;
+	        let residualCount = 0;
+	        let residualMaxPct = 0;
+	        const residuals = [];
+	        for (const pair of inputPairs) {
+	            const px = affine.a * pair.sx + affine.b * pair.sy + affine.c;
+	            const py = affine.d * pair.sx + affine.e * pair.sy + affine.f;
+	            const rx = pair.tx - px;
+	            const ry = pair.ty - py;
+	            const magnitude = Math.hypot(rx, ry);
+	            if (magnitude < 1e-4)
+	                continue;
+	            const radiusRef = Math.hypot(px, py);
+	            const pct = (magnitude / Math.max(0.2, radiusRef)) * 100;
+	            residualSumPct += pct;
+	            residualCount += 1;
+	            residualMaxPct = Math.max(residualMaxPct, pct);
+	            residuals.push({ sx: pair.sx, sy: pair.sy, px, py, rx, ry, magnitude, pct });
+	        }
+	        const result = {
+	            ...affine,
+	            count: inputPairs.length,
+	            residualAvgPct: residualCount ? residualSumPct / residualCount : 0,
+	            residualMaxPct,
+	            residuals,
+	        };
+	        this.lastResult = result;
+	        return result;
+	    }
+	    /**
+	     * 마지막 affine 추정 결과를 반환합니다.
+	     */
+	    getLastResult() {
+	        return this.lastResult;
+	    }
+	    /**
+	     * 마지막 affine 추정에 사용된 입력쌍을 반환합니다.
+	     */
+	    getLastPairs() {
+	        return [...this.lastPairs];
+	    }
+	    fitAffine2D(pairs) {
+	        if (!Array.isArray(pairs) || pairs.length < 4)
+	            return null;
+	        const ata = Array.from({ length: 6 }, () => Array(6).fill(0));
+	        const atb = Array(6).fill(0);
+	        const accumulate = (row, rhs) => {
+	            for (let i = 0; i < 6; i += 1) {
+	                atb[i] += row[i] * rhs;
+	                for (let j = 0; j < 6; j += 1)
+	                    ata[i][j] += row[i] * row[j];
+	            }
+	        };
+	        for (const pair of pairs) {
+	            accumulate([pair.sx, pair.sy, 1, 0, 0, 0], pair.tx);
+	            accumulate([0, 0, 0, pair.sx, pair.sy, 1], pair.ty);
+	        }
+	        const n = 6;
+	        const aug = ata.map((row, index) => [...row, atb[index]]);
+	        for (let col = 0; col < n; col += 1) {
+	            let pivot = col;
+	            for (let row = col + 1; row < n; row += 1) {
+	                if (Math.abs(aug[row][col]) > Math.abs(aug[pivot][col]))
+	                    pivot = row;
+	            }
+	            if (Math.abs(aug[pivot][col]) < 1e-10)
+	                return null;
+	            if (pivot !== col) {
+	                const temp = aug[col];
+	                aug[col] = aug[pivot];
+	                aug[pivot] = temp;
+	            }
+	            const divider = aug[col][col];
+	            for (let j = col; j <= n; j += 1)
+	                aug[col][j] /= divider;
+	            for (let row = 0; row < n; row += 1) {
+	                if (row === col)
+	                    continue;
+	                const factor = aug[row][col];
+	                if (Math.abs(factor) < 1e-12)
+	                    continue;
+	                for (let j = col; j <= n; j += 1)
+	                    aug[row][j] -= factor * aug[col][j];
+	            }
+	        }
+	        return {
+	            a: aug[0][n],
+	            b: aug[1][n],
+	            c: aug[2][n],
+	            d: aug[3][n],
+	            e: aug[4][n],
+	            f: aug[5][n],
+	        };
+	    }
+	}
+
 	class LightSource {
 	    constructor() {
 	        this.rays = [];
+	        this.sourcePosition = new Vector3(0, 0, 0);
+	        this.sourceRotationQuaternion = new Quaternion();
+	        this.sourceRotationPivot = new Vector3(0, 0, 0);
 	    }
 	    directionFromVergence(origin, z, vergence) {
 	        if (!Number.isFinite(vergence) || Math.abs(vergence) < 1e-12) {
@@ -7167,13 +7170,62 @@
 	    addRay(ray) {
 	        this.rays.push(ray.clone());
 	    }
+	    configurePose(pose, pivotZ = 0) {
+	        const position = pose?.position;
+	        const tilt = pose?.tilt;
+	        this.sourcePosition = new Vector3(this.toFiniteNumber(position?.x), this.toFiniteNumber(position?.y), this.toFiniteNumber(position?.z));
+	        const tiltXDeg = this.toFiniteNumber(tilt?.x);
+	        const tiltYDeg = this.toFiniteNumber(tilt?.y);
+	        this.sourceRotationQuaternion = new Quaternion().setFromEuler(new Euler((tiltXDeg * Math.PI) / 180, (tiltYDeg * Math.PI) / 180, 0, "XYZ"));
+	        this.sourceRotationPivot = new Vector3(0, 0, this.toFiniteNumber(pivotZ));
+	    }
+	    toFiniteNumber(value, fallback = 0) {
+	        const parsed = Number(value);
+	        return Number.isFinite(parsed) ? parsed : fallback;
+	    }
+	    getRayPoints(ray) {
+	        const state = ray;
+	        return Array.isArray(state.points) ? state.points : [];
+	    }
+	    rotatePointAroundPivot(point, pivot) {
+	        return point.clone().sub(pivot).applyQuaternion(this.sourceRotationQuaternion).add(pivot);
+	    }
+	    transformRayAroundPivot(ray) {
+	        const points = this.getRayPoints(ray);
+	        if (!points.length)
+	            return ray;
+	        const transformed = ray.clone();
+	        const transformedState = transformed;
+	        const nextPoints = points.map((point) => this.rotatePointAroundPivot(point, this.sourceRotationPivot));
+	        transformedState.points = nextPoints;
+	        transformedState.direction = ray.getDirection().clone().applyQuaternion(this.sourceRotationQuaternion).normalize();
+	        transformedState.origin = nextPoints[nextPoints.length - 1].clone();
+	        return transformed;
+	    }
+	    translateRay(ray) {
+	        if (this.sourcePosition.lengthSq() < 1e-12)
+	            return ray;
+	        const points = this.getRayPoints(ray);
+	        if (!points.length)
+	            return ray;
+	        const translated = ray.clone();
+	        const translatedState = translated;
+	        const nextPoints = points.map((point) => point.clone().add(this.sourcePosition));
+	        translatedState.points = nextPoints;
+	        translatedState.origin = nextPoints[nextPoints.length - 1].clone();
+	        return translated;
+	    }
+	    applyPoseToRay(ray) {
+	        const rotated = this.transformRayAroundPivot(ray.clone());
+	        return this.translateRay(rotated);
+	    }
 	    emitRays() {
-	        return this.rays.map((ray) => ray.clone());
+	        return this.rays.map((ray) => this.applyPoseToRay(ray));
 	    }
 	}
 	class GridLightSource extends LightSource {
 	    constructor(props) {
-	        const { width, height, division = 4, z, vergence = 0 } = props;
+	        const { width, height, division = 4, z, vergence = 0, position, tilt } = props;
 	        if (division < 4) {
 	            throw new Error("division must be greater than 4");
 	        }
@@ -7194,6 +7246,7 @@
 	        this.division = division;
 	        this.z = z;
 	        this.vergence = vergence;
+	        this.configurePose({ position, tilt }, this.z);
 	        const xStep = this.division > 1 ? this.width / (this.division - 1) : 0;
 	        const yStep = this.division > 1 ? this.height / (this.division - 1) : 0;
 	        const xStart = -this.width / 2;
@@ -7210,7 +7263,7 @@
 	}
 	class GridRGLightSource extends LightSource {
 	    constructor(props) {
-	        const { width, height, division = 4, z, vergence = 0 } = props;
+	        const { width, height, division = 4, z, vergence = 0, position, tilt } = props;
 	        if (division < 4) {
 	            throw new Error("division must be greater than 4");
 	        }
@@ -7231,6 +7284,7 @@
 	        this.division = division;
 	        this.z = z;
 	        this.vergence = vergence;
+	        this.configurePose({ position, tilt }, this.z);
 	        const xStep = this.division > 1 ? this.width / (this.division - 1) : 0;
 	        const yStep = this.division > 1 ? this.height / (this.division - 1) : 0;
 	        const xStart = -this.width / 2;
@@ -7248,7 +7302,7 @@
 	}
 	class RadialLightSource extends LightSource {
 	    constructor(props) {
-	        const { radius, division = 4, angle_division = 4, z, vergence = 0 } = props;
+	        const { radius, division = 4, angle_division = 4, z, vergence = 0, position, tilt } = props;
 	        if (radius < 0) {
 	            throw new Error("radius must be greater than or equal to 0");
 	        }
@@ -7272,6 +7326,7 @@
 	        this.angle_division = angle_division;
 	        this.z = z;
 	        this.vergence = vergence;
+	        this.configurePose({ position, tilt }, this.z);
 	        this.createRayFromPoint(new Vector3(0, 0, this.z), this.z, this.vergence);
 	        for (let ring = 1; ring <= this.division; ring += 1) {
 	            const ringRadius = (this.radius * ring) / this.division;
@@ -7286,26 +7341,76 @@
 	    }
 	}
 
-	function isFiniteNumber(value) {
-	    return typeof value === "number" && Number.isFinite(value);
+	/** 각막 기준 안구 회전점 z(mm). `SCAXEngineCore`와 동일. */
+	const EYE_ROTATION_PIVOT_FROM_CORNEA_MM = 13;
+	function normalizePrismAmount$2(value) {
+	    const p = Number(value ?? 0);
+	    return Number.isFinite(p) ? Math.max(0, p) : 0;
 	}
-	function resolveRefractiveIndex(spec, line) {
-	    if (isFiniteNumber(spec))
-	        return spec;
-	    const lineValue = spec[line];
-	    if (isFiniteNumber(lineValue))
-	        return lineValue;
-	    const dValue = spec.d;
-	    if (isFiniteNumber(dValue))
-	        return dValue;
-	    return 1.0;
+	function normalizeAngle360$2(value) {
+	    const d = Number(value ?? 0);
+	    if (!Number.isFinite(d))
+	        return 0;
+	    return ((d % 360) + 360) % 360;
 	}
-	function normalizeRefractiveIndexSpec(spec) {
-	    if (!isFiniteNumber(spec))
-	        return spec;
-	    const entries = Object.values(FRAUNHOFER_REFRACTIVE_INDICES);
-	    const matched = entries.find((item) => isFiniteNumber(item.d) && Math.abs(item.d - spec) < 1e-6);
-	    return matched ?? spec;
+	function prismVectorFromBase(prismDiopter, baseAngleDeg) {
+	    const p = normalizePrismAmount$2(prismDiopter);
+	    const baseAngle = normalizeAngle360$2(baseAngleDeg);
+	    const deviationAngle = normalizeAngle360$2(baseAngle + 180);
+	    const rad = (-deviationAngle * Math.PI) / 180;
+	    return {
+	        x: p * Math.cos(rad),
+	        y: p * Math.sin(rad),
+	    };
+	}
+	function prismComponentToAngleDeg(componentPrism) {
+	    const c = Number(componentPrism);
+	    if (!Number.isFinite(c))
+	        return 0;
+	    return (Math.atan(c / 100) * 180) / Math.PI;
+	}
+	/** eye 처방(Base) → 실제 안구 편향에 쓰는 역벡터(내부 x/y, Δ). */
+	function eyePrismEffectVectorFromPrescription(p, p_ax) {
+	    const eyeRx = prismVectorFromBase(normalizePrismAmount$2(p), normalizeAngle360$2(p_ax));
+	    return { x: -eyeRx.x, y: -eyeRx.y };
+	}
+	/**
+	 * eye.p / eye.p_ax(임상 Base) 및 eye.tilt(°)로부터
+	 * 안구 강체 회전 쿼터니언(Euler XYZ, z=0). 기존 configure 광선 피벗 회전과 동일.
+	 */
+	function eyePrismAndTiltToQuaternion(p, p_ax, tiltDeg) {
+	    const { x, y } = eyePrismEffectVectorFromPrescription(p, p_ax);
+	    const eyeRotXDeg = prismComponentToAngleDeg(x);
+	    const eyeRotYDeg = prismComponentToAngleDeg(y);
+	    const eyeEulerXDeg = eyeRotYDeg + tiltDeg.x;
+	    const eyeEulerYDeg = (-eyeRotXDeg) + tiltDeg.y;
+	    return new Quaternion().setFromEuler(new Euler((eyeEulerXDeg * Math.PI) / 180, (eyeEulerYDeg * Math.PI) / 180, 0, "XYZ"));
+	}
+	function eyeRotationPivot() {
+	    return new Vector3(0, 0, EYE_ROTATION_PIVOT_FROM_CORNEA_MM);
+	}
+	/** eye prism/tilt를 반영한 렌더용 각도(°). */
+	function eyeRotationForRenderDegrees(p, p_ax, tiltDeg) {
+	    const { x, y } = eyePrismEffectVectorFromPrescription(p, p_ax);
+	    const eyeRotXDeg = prismComponentToAngleDeg(x);
+	    const eyeRotYDeg = prismComponentToAngleDeg(y);
+	    const eyeEulerXDeg = eyeRotYDeg + tiltDeg.x;
+	    const eyeEulerYDeg = (-eyeRotXDeg) + tiltDeg.y;
+	    const xDeg = eyeEulerYDeg;
+	    const yDeg = -eyeEulerXDeg;
+	    return {
+	        x_deg: xDeg,
+	        y_deg: yDeg,
+	        magnitude_deg: Math.hypot(xDeg, yDeg),
+	    };
+	}
+	/**
+	 * 안구 회전점 기준 강체 회전을 각 표면의 world `position` / `tilt`에 반영합니다.
+	 */
+	function applyRigidEyePoseToSurfaces(surfaces, pivot, rotation) {
+	    for (const surface of surfaces) {
+	        surface.applyRigidRotationAboutPivot(pivot, rotation);
+	    }
 	}
 
 	class Surface {
@@ -7327,6 +7432,118 @@
 	        this.incidentRays = [];
 	        this.refractedRays = [];
 	    }
+	    getWorldPosition() {
+	        return this.position.clone();
+	    }
+	    setPositionAndTilt(position, tiltXDeg, tiltYDeg) {
+	        this.position.copy(position);
+	        this.tilt.set(tiltXDeg, tiltYDeg);
+	    }
+	    /**
+	     * 안질 tilt가 0인 표면을 전제로, pivot 기준 강체 회전 후 동일 Euler(XYZ) tilt를 부여합니다.
+	     */
+	    applyRigidRotationAboutPivot(pivot, rotation) {
+	        const p1 = pivot.clone().add(new Vector3().subVectors(this.position, pivot).applyQuaternion(rotation));
+	        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
+	        this.position.copy(p1);
+	        this.tilt.set((euler.x * 180) / Math.PI, (euler.y * 180) / Math.PI);
+	    }
+	}
+
+	class ApertureStopSurface extends Surface {
+	    constructor(props) {
+	        super({
+	            type: "aperture_stop",
+	            name: props.name,
+	            position: props.position,
+	            tilt: props.tilt,
+	        });
+	        this.shape = props.shape;
+	        this.radius = Math.max(0, Number(props.radius ?? 0));
+	        this.width = Math.max(0, Number(props.width ?? 0));
+	        this.height = Math.max(0, Number(props.height ?? 0));
+	    }
+	    worldQuaternion() {
+	        const tiltXRad = (this.tilt.x * Math.PI) / 180;
+	        const tiltYRad = (this.tilt.y * Math.PI) / 180;
+	        return new Quaternion().setFromEuler(new Euler(tiltXRad, tiltYRad, 0, "XYZ"));
+	    }
+	    localPointFromWorld(worldPoint) {
+	        const inverse = this.worldQuaternion().invert();
+	        return worldPoint
+	            .clone()
+	            .sub(this.position)
+	            .applyQuaternion(inverse);
+	    }
+	    surfaceNormalWorld() {
+	        return new Vector3(0, 0, 1).applyQuaternion(this.worldQuaternion()).normalize();
+	    }
+	    intersectForward(origin, direction) {
+	        const normal = this.surfaceNormalWorld();
+	        const denom = normal.dot(direction);
+	        if (Math.abs(denom) < EPSILON)
+	            return null;
+	        const t = normal.dot(this.position.clone().sub(origin)) / denom;
+	        if (!Number.isFinite(t) || t <= 1e-6)
+	            return null;
+	        return origin.clone().addScaledVector(direction, t);
+	    }
+	    isInsideAperture(hitPointWorld) {
+	        const local = this.localPointFromWorld(hitPointWorld);
+	        if (this.shape === "circle") {
+	            if (this.radius <= 0)
+	                return false;
+	            return Math.hypot(local.x, local.y) <= this.radius + 1e-9;
+	        }
+	        if (this.width <= 0 || this.height <= 0)
+	            return false;
+	        return (Math.abs(local.x) <= (this.width / 2) + 1e-9
+	            && Math.abs(local.y) <= (this.height / 2) + 1e-9);
+	    }
+	    incident(ray) {
+	        const origin = ray.endPoint();
+	        const direction = ray.getDirection().normalize();
+	        const hitPoint = this.intersectForward(origin, direction);
+	        if (!hitPoint)
+	            return null;
+	        if (!this.isInsideAperture(hitPoint))
+	            return null;
+	        this.incidentRays.push(ray.clone());
+	        return hitPoint;
+	    }
+	    refract(ray) {
+	        const hitPoint = this.incident(ray);
+	        if (!hitPoint)
+	            return null;
+	        const direction = ray.getDirection().normalize();
+	        const passedRay = ray.clone();
+	        passedRay.appendPoint(hitPoint);
+	        passedRay.continueFrom(hitPoint.clone().addScaledVector(direction, RAY_SURFACE_ESCAPE_MM), direction);
+	        this.refractedRays.push(passedRay.clone());
+	        return passedRay;
+	    }
+	}
+
+	function isFiniteNumber(value) {
+	    return typeof value === "number" && Number.isFinite(value);
+	}
+	function resolveRefractiveIndex(spec, line) {
+	    if (isFiniteNumber(spec))
+	        return spec;
+	    const lineValue = spec[line];
+	    if (isFiniteNumber(lineValue))
+	        return lineValue;
+	    const dValue = spec.d;
+	    if (isFiniteNumber(dValue))
+	        return dValue;
+	    return 1.0;
+	}
+	function normalizeRefractiveIndexSpec(spec) {
+	    if (!isFiniteNumber(spec))
+	        return spec;
+	    const entries = Object.values(FRAUNHOFER_REFRACTIVE_INDICES);
+	    const matched = entries.find((item) => isFiniteNumber(item.d) && Math.abs(item.d - spec) < 1e-6);
+	    return matched ?? spec;
 	}
 
 	class AsphericalSurface extends Surface {
@@ -7855,1083 +8072,1223 @@
 	    }
 	}
 
-	class EyeModelParameter {
-	    constructor(parameter) {
-	        this.parameter = parameter;
-	    }
-	    createSurface() {
-	        return this.parameter.surfaces.map((surface) => {
-	            if (surface.type === "spherical") {
-	                return new SphericalSurface({
-	                    type: "spherical",
-	                    name: surface.name,
-	                    r: surface.radius,
-	                    position: { x: 0, y: 0, z: surface.z },
-	                    tilt: { x: 0, y: 0 },
-	                    n_before: surface.n_before,
-	                    n_after: surface.n_after,
-	                });
-	            }
-	            if (surface.type === "aspherical") {
-	                return new AsphericalSurface({
-	                    type: "aspherical",
-	                    name: surface.name,
-	                    position: { x: 0, y: 0, z: surface.z },
-	                    tilt: { x: 0, y: 0 },
-	                    r: surface.radius,
-	                    conic: surface.conic,
-	                    n_before: surface.n_before,
-	                    n_after: surface.n_after,
-	                });
-	            }
-	            if (surface.type === "spherical-image") {
-	                return new SphericalImageSurface({
-	                    type: "spherical-image",
-	                    name: surface.name,
-	                    r: surface.radius,
-	                    position: { x: 0, y: 0, z: surface.z },
-	                    tilt: { x: 0, y: 0 },
-	                    retina_extra_after: true,
-	                });
-	            }
-	            throw new Error(`Unsupported surface type: ${surface.type}`);
-	        });
-	    }
+	function normalizePrismDiopters(value) {
+	    const p = Number(value ?? 0);
+	    return Number.isFinite(p) ? Math.max(0, p) : 0;
 	}
-
-	class GullstrandParameter extends EyeModelParameter {
-	    constructor() {
-	        super(GullstrandParameter.parameter);
-	    }
+	function normalizeAngle360Degrees(value) {
+	    const d = Number(value ?? 0);
+	    if (!Number.isFinite(d))
+	        return 0;
+	    return ((d % 360) + 360) % 360;
 	}
-	GullstrandParameter.parameter = {
-	    unit: "mm",
-	    axis: "optical_axis_z",
-	    origin: "cornea_anterior_vertex",
-	    surfaces: [
-	        {
-	            type: "spherical",
-	            name: "cornea_anterior",
-	            z: 0.0,
-	            radius: 7.7,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
-	        },
-	        {
-	            type: "spherical",
-	            name: "cornea_posterior",
-	            z: 0.5,
-	            radius: 6.8,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
-	        },
-	        {
-	            type: "spherical",
-	            name: "lens_anterior",
-	            z: 3.6,
-	            radius: 10.0,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
-	        },
-	        {
-	            type: "spherical",
-	            name: "lens_nucleus_anterior",
-	            z: 4.146,
-	            radius: 7.911,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
-	        },
-	        {
-	            type: "spherical",
-	            name: "lens_nucleus_posterior",
-	            z: 6.565,
-	            radius: -5.76,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
-	        },
-	        {
-	            type: "spherical",
-	            name: "lens_posterior",
-	            z: 7.2,
-	            radius: -6,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
-	        },
-	        {
-	            type: "spherical-image",
-	            name: "retina",
-	            radius: -12, // mm (대략적인 망막 곡률)
-	            z: 24.0 // 중심 위치
-	        }
-	    ],
+	/**
+	 * 임상 프리즘 Base(Δ, 렌즈→각막 시점 °)를 내부 x/y 프리즘 벡터(Δ)로 변환합니다.
+	 * `SCAXEngineCore`와 동일한 관례입니다.
+	 */
+	function prismVectorFromClinicalBase(prismDiopter, baseAngleDeg) {
+	    const p = normalizePrismDiopters(prismDiopter);
+	    const baseAngle = normalizeAngle360Degrees(baseAngleDeg);
+	    const deviationAngle = normalizeAngle360Degrees(baseAngle + 180);
+	    const rad = (-deviationAngle * Math.PI) / 180;
+	    return {
+	        x: p * Math.cos(rad),
+	        y: p * Math.sin(rad),
+	    };
+	}
+	/**
+	 * 굴절 직후 광선에 프리즘 편향(소각 근사)을 적용합니다.
+	 */
+	function applyPrismVectorToRay(ray, prism) {
+	    const px = Number(prism?.x ?? 0);
+	    const py = Number(prism?.y ?? 0);
+	    if (!Number.isFinite(px)
+	        || !Number.isFinite(py)
+	        || (Math.abs(px) < 1e-12 && Math.abs(py) < 1e-12)) {
+	        return ray;
+	    }
+	    const direction = ray.getDirection();
+	    const dz = Number(direction.z);
+	    if (!Number.isFinite(dz) || Math.abs(dz) < 1e-12)
+	        return ray;
+	    const tx = (direction.x / dz) + (px / 100);
+	    const ty = (direction.y / dz) + (py / 100);
+	    const signZ = dz >= 0 ? 1 : -1;
+	    const newDirection = new Vector3(tx * signZ, ty * signZ, signZ).normalize();
+	    if (!Number.isFinite(newDirection.x) || !Number.isFinite(newDirection.y) || !Number.isFinite(newDirection.z)) {
+	        return ray;
+	    }
+	    const updated = ray.clone();
+	    const origin = updated.endPoint();
+	    updated.continueFrom(origin.clone().addScaledVector(newDirection, RAY_SURFACE_ESCAPE_MM), newDirection);
+	    return updated;
+	}
+
+	const DegToTABO = (degree) => {
+	    const d = Number(degree);
+	    if (!Number.isFinite(d))
+	        return 0;
+	    return (((180 - d) % 180) + 180) % 180;
 	};
 
-	class NavarroParameter extends EyeModelParameter {
-	    constructor() {
-	        super(NavarroParameter.parameter);
-	    }
-	}
-	NavarroParameter.parameter = {
-	    unit: "mm",
-	    axis: "optical_axis_z",
-	    surfaces: [
-	        {
-	            type: "aspherical",
-	            name: "cornea_anterior",
-	            z: 0.0,
-	            radius: 7.72,
-	            conic: -0.26,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
-	        },
-	        {
-	            type: "aspherical",
-	            name: "cornea_posterior",
-	            z: 0.55,
-	            radius: 6.5,
-	            conic: 0.0,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
-	        },
-	        {
-	            type: "aspherical",
-	            name: "lens_anterior",
-	            z: 0.55 + 3.05,
-	            radius: 10.2,
-	            conic: -3.13,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
-	        },
-	        {
-	            type: "aspherical",
-	            name: "lens_posterior",
-	            z: 0.55 + 3.05 + 4.0,
-	            radius: -6,
-	            conic: -1,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
-	        },
-	        {
-	            type: "spherical-image",
-	            name: "retina",
-	            radius: -12, // mm (대략적인 망막 곡률)
-	            z: 24.04 // 중심 위치
-	        }
-	    ],
-	};
-
-	/**
-	 * Sturm 계산 전용 클래스입니다.
-	 * - traced ray 집합에서 z-scan slice를 생성하고
-	 * - 평탄도/최소타원/근사중심을 계산해 분석 결과를 반환합니다.
-	 */
-	class Sturm {
-	    constructor() {
-	        this.lastResult = null;
-	        this.lineOrder = ["g", "F", "e", "d", "C", "r"];
+	class ToricSurface extends Surface {
+	    constructor(props) {
+	        super({ type: "toric", name: props.name, position: props.position, tilt: props.tilt });
+	        this.r_axis = 0;
+	        this.r_perp = 0;
+	        this.n_before = 1.0;
+	        this.n_after = 1.0;
+	        this.axisDeg = 0;
+	        const { r_axis, r_perp, axis_deg = 0, n_before = 1.0, n_after = 1.0 } = props;
+	        this.r_axis = r_axis;
+	        this.r_perp = r_perp;
+	        this.axisDeg = axis_deg;
+	        this.n_before = normalizeRefractiveIndexSpec(n_before);
+	        this.n_after = normalizeRefractiveIndexSpec(n_after);
 	    }
-	    calculate(rays, effectiveCylinderD, axisReferenceRays, profileWorldZBounds) {
-	        const frame = this.analysisFrameFromRays(axisReferenceRays?.length ? axisReferenceRays : rays);
-	        const depthRange = this.depthRangeFromRays(rays, frame);
-	        const sturmSlices = this.collectSturmSlices(rays, frame, depthRange, DEFAULT_STURM_STEP_MM);
-	        const groupedByLine = this.groupByFraunhoferLine(rays);
-	        const sturmInfo = groupedByLine.map((group) => {
-	            const groupFrame = this.analysisFrameFromRays(group.rays, frame);
-	            const groupDepthRange = this.depthRangeFromRays(group.rays, groupFrame);
-	            const slices = this.collectSturmSlices(group.rays, groupFrame, groupDepthRange, DEFAULT_STURM_STEP_MM);
-	            const analysis = this.analyzeSturmSlices(slices, effectiveCylinderD, profileWorldZBounds);
-	            return {
-	                line: group.line,
-	                wavelength_nm: group.wavelength_nm,
-	                color: group.color,
-	                ray_count: group.rays.length,
-	                analysis_axis: {
-	                    x: groupFrame.axis.x,
-	                    y: groupFrame.axis.y,
-	                    z: groupFrame.axis.z,
-	                },
-	                ...analysis,
-	            };
-	        });
-	        const result = {
-	            slices_info: {
-	                count: sturmSlices.length,
-	                slices: sturmSlices,
-	            },
-	            sturm_info: sturmInfo,
+	    refractiveIndicesForRay(ray) {
+	        const line = ray.getFraunhoferLine();
+	        return {
+	            nBefore: resolveRefractiveIndex(this.n_before, line),
+	            nAfter: resolveRefractiveIndex(this.n_after, line),
 	        };
-	        this.lastResult = result;
-	        return result;
 	    }
 	    /**
-	     * 마지막 Sturm 계산 결과를 반환합니다.
+	     * Toric 면의 축(meridian) 회전을 위해 사용하는 삼각함수 값입니다.
+	     * 축(axis) 회전은 axisDeg(도 단위)를 사용합니다.
 	     */
-	    getLastResult() {
-	        return this.lastResult;
+	    axisTrig() {
+	        const rad = (this.axisDeg * Math.PI) / 180;
+	        return { c: Math.cos(rad), s: Math.sin(rad) };
 	    }
-	    getRayPoints(ray) {
-	        const points = ray.points;
-	        return Array.isArray(points) ? points : [];
+	    worldQuaternion() {
+	        const tiltXRad = (this.tilt.x * Math.PI) / 180;
+	        const tiltYRad = (this.tilt.y * Math.PI) / 180;
+	        return new Quaternion().setFromEuler(new Euler(tiltXRad, tiltYRad, 0, "XYZ"));
 	    }
-	    analysisFrameFromRays(rays, fallback) {
-	        const axis = new Vector3();
-	        for (const ray of rays ?? [])
-	            axis.add(ray.getDirection());
-	        if (axis.lengthSq() < 1e-12) {
-	            if (fallback)
-	                return fallback;
-	            axis.set(0, 0, 1);
-	        }
-	        else {
-	            axis.normalize();
-	        }
-	        const origin = new Vector3(0, 0, 0);
-	        let helper = new Vector3(0, 1, 0);
-	        if (Math.abs(helper.dot(axis)) > 0.95)
-	            helper = new Vector3(1, 0, 0);
-	        const u = helper.clone().cross(axis).normalize();
-	        const v = axis.clone().cross(u).normalize();
-	        return { origin, axis, u, v };
+	    worldPointToLocal(worldPoint) {
+	        const inverse = this.worldQuaternion().invert();
+	        return worldPoint.clone().sub(this.position).applyQuaternion(inverse);
 	    }
-	    sampleRayPointAtDepth(ray, frame, depth) {
-	        const points = this.getRayPoints(ray);
-	        for (let i = 0; i < points.length - 1; i += 1) {
-	            const a = points[i];
-	            const b = points[i + 1];
-	            const da = a.clone().sub(frame.origin).dot(frame.axis);
-	            const db = b.clone().sub(frame.origin).dot(frame.axis);
-	            if ((da <= depth && depth <= db) || (db <= depth && depth <= da)) {
-	                const denom = db - da;
-	                if (Math.abs(denom) < 1e-10)
-	                    return null;
-	                return a.clone().lerp(b, (depth - da) / denom);
-	            }
-	        }
-	        return null;
+	    localPointToWorld(localPoint) {
+	        return localPoint.clone().applyQuaternion(this.worldQuaternion()).add(this.position);
 	    }
-	    depthRangeFromRays(rays, frame) {
-	        let depthMin = Number.POSITIVE_INFINITY;
-	        let depthMax = Number.NEGATIVE_INFINITY;
-	        for (const ray of rays ?? []) {
-	            for (const point of this.getRayPoints(ray)) {
-	                const d = point.clone().sub(frame.origin).dot(frame.axis);
-	                depthMin = Math.min(depthMin, d);
-	                depthMax = Math.max(depthMax, d);
-	            }
-	        }
-	        if (!Number.isFinite(depthMin) || !Number.isFinite(depthMax) || depthMax <= depthMin)
-	            return null;
-	        return { depthMin, depthMax };
+	    worldDirToLocal(worldDirection) {
+	        const inverse = this.worldQuaternion().invert();
+	        return worldDirection.clone().applyQuaternion(inverse).normalize();
 	    }
-	    secondMomentProfileAtDepth(rays, frame, depth) {
-	        const points = [];
-	        for (const ray of rays) {
-	            const point = this.sampleRayPointAtDepth(ray, frame, depth);
-	            if (point)
-	                points.push(point);
-	        }
-	        if (points.length < 4)
-	            return null;
-	        let cxWorld = 0;
-	        let cyWorld = 0;
-	        let czWorld = 0;
-	        let cx = 0;
-	        let cy = 0;
-	        for (const p of points) {
-	            cxWorld += p.x;
-	            cyWorld += p.y;
-	            czWorld += p.z;
-	            const delta = p.clone().sub(frame.origin);
-	            cx += delta.dot(frame.u);
-	            cy += delta.dot(frame.v);
-	        }
-	        cxWorld /= points.length;
-	        cyWorld /= points.length;
-	        czWorld /= points.length;
-	        cx /= points.length;
-	        cy /= points.length;
-	        let sxx = 0;
-	        let syy = 0;
-	        let sxy = 0;
-	        for (const p of points) {
-	            const delta = p.clone().sub(frame.origin);
-	            const x = delta.dot(frame.u);
-	            const y = delta.dot(frame.v);
-	            const dx = x - cx;
-	            const dy = y - cy;
-	            sxx += dx * dx;
-	            syy += dy * dy;
-	            sxy += dx * dy;
-	        }
-	        sxx /= points.length;
-	        syy /= points.length;
-	        sxy /= points.length;
-	        const trace = sxx + syy;
-	        const halfDiff = (sxx - syy) / 2;
-	        const root = Math.sqrt(Math.max(0, halfDiff * halfDiff + sxy * sxy));
-	        const lambdaMajor = Math.max(0, trace / 2 + root);
-	        const lambdaMinor = Math.max(0, trace / 2 - root);
-	        const thetaRad = 0.5 * Math.atan2(2 * sxy, sxx - syy);
-	        const angleMajorDeg = ((thetaRad * 180) / Math.PI + 360) % 180;
-	        const twoThetaRad = 2 * thetaRad;
-	        const j0 = Math.cos(twoThetaRad);
-	        const j45 = Math.sin(twoThetaRad);
-	        const majorDirection = frame.u.clone().multiplyScalar(Math.cos(thetaRad))
-	            .add(frame.v.clone().multiplyScalar(Math.sin(thetaRad)))
-	            .normalize();
-	        const minorDirection = frame.axis.clone().cross(majorDirection).normalize();
-	        return {
-	            at: { x: cxWorld, y: cyWorld, z: czWorld },
-	            wMajor: Math.sqrt(lambdaMajor),
-	            wMinor: Math.sqrt(lambdaMinor),
-	            angleMajorDeg,
-	            j0,
-	            j45,
-	            angleMinorDeg: (angleMajorDeg + 90) % 180,
-	            majorDirection: {
-	                x: majorDirection.x,
-	                y: majorDirection.y,
-	                z: majorDirection.z,
-	            },
-	            minorDirection: {
-	                x: minorDirection.x,
-	                y: minorDirection.y,
-	                z: minorDirection.z,
-	            },
-	        };
+	    localDirToWorld(localDirection) {
+	        return localDirection.clone().applyQuaternion(this.worldQuaternion()).normalize();
 	    }
-	    collectSturmSlices(rays, frame, depthRange, stepMm) {
-	        if (!depthRange)
-	            return [];
-	        const out = [];
-	        for (let depth = depthRange.depthMin; depth <= depthRange.depthMax; depth += stepMm) {
-	            const profile = this.secondMomentProfileAtDepth(rays, frame, depth);
-	            if (!profile)
-	                continue;
-	            out.push({
-	                // Keep z in world coordinates for backward-compatible consumers.
-	                z: profile.at.z,
-	                // Preserve analysis-axis depth for off-axis robust ranking/interval logic.
-	                depth,
-	                ratio: profile.wMinor / Math.max(profile.wMajor, 1e-9),
-	                size: Math.hypot(profile.wMajor, profile.wMinor),
-	                profile,
-	            });
-	        }
-	        return out;
+	    /**
+	     * 월드 좌표계 (x, y)를 토릭 로컬 좌표계 (u, v)로 변환합니다.
+	     * - u: 축 방향 meridian
+	     * - v: 축에 수직인 meridian
+	     */
+	    toLocalUV(x, y) {
+	        const { c, s } = this.axisTrig();
+	        return {
+	            u: c * x + s * y,
+	            v: -s * x + c * y,
+	        };
 	    }
-	    axisDiffDeg(a, b) {
-	        const d = Math.abs((((a - b) % 180) + 180) % 180);
-	        return Math.min(d, 180 - d);
+	    /**
+	     * 로컬 좌표계에서 계산한 sag 미분(dz/du, dz/dv)을
+	     * 월드 좌표계의 기울기(dz/dx, dz/dy)로 다시 매핑합니다.
+	     */
+	    localDerivativesToWorld(dZdu, dZdv) {
+	        const { c, s } = this.axisTrig();
+	        return {
+	            dzdx: dZdu * c - dZdv * s,
+	            dzdy: dZdu * s + dZdv * c,
+	        };
 	    }
-	    phasorDot(p, q) {
-	        return p.j0 * q.j0 + p.j45 * q.j45;
+	    /**
+	     * 반경으로부터 곡률(1/R)을 계산합니다.
+	     * - 반경이 너무 크거나 무한대면 평면으로 간주하여 0 반환
+	     * - 반경이 0에 너무 가까우면 비정상 값으로 NaN 반환
+	     */
+	    curvature(radius) {
+	        if (!Number.isFinite(radius) || Math.abs(radius) > 1e12)
+	            return 0;
+	        if (Math.abs(radius) < EPSILON)
+	            return Number.NaN;
+	        return 1 / radius;
 	    }
 	    /**
-	     * 평탄도 순으로 정렬된 슬라이스에서 선초점 쌍(직교 주경선)에 해당하는 Top2를 고른다.
-	     * 주경선 각 대신 이각 phasor (cos 2θ, sin 2θ)로 직교를 판정하고, 실패 시 각도·전역 검색·깊이 폴백을 사용한다.
+	     * 주어진 XY에서 토릭면의 기하정보를 계산합니다.
+	     * - sag: 꼭지점 대비 z 높이
+	     * - dzdx/dzdy: 면 기울기
+	     * - normal: 2번째 매질 방향을 만들 때 사용할 기본 법선
 	     */
-	    pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, allSlices) {
-	        if (sortedByFlatness.length === 0)
-	            return [];
-	        const first = sortedByFlatness[0];
-	        const top2MinAngleGapDeg = DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG;
-	        const phasorStrict = DEFAULT_STURM_TOP2_PHASOR_OPPOSITION_MAX_DOT;
-	        const phasorLoose = DEFAULT_STURM_TOP2_PHASOR_FALLBACK_MAX_DOT;
-	        const lastResortMinDeg = DEFAULT_STURM_TOP2_AXIS_LAST_RESORT_MIN_GAP_DEG;
-	        const depthOk = (c) => Math.abs(c.depth - first.depth) >= top2MinGapMm;
-	        const byPhasor = (pool, maxDot) => pool.find((c) => (c !== first
-	            && depthOk(c)
-	            && this.phasorDot(first.profile, c.profile) <= maxDot));
-	        let second = byPhasor(sortedByFlatness, phasorStrict)
-	            ?? byPhasor(sortedByFlatness, phasorLoose);
-	        if (!second) {
-	            second = sortedByFlatness.find((c) => (c !== first
-	                && depthOk(c)
-	                && this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg) >= top2MinAngleGapDeg));
-	        }
-	        if (!second) {
-	            let best = null;
-	            let bestAxDiff = -1;
-	            for (const c of sortedByFlatness) {
-	                if (c === first || !depthOk(c))
-	                    continue;
-	                const axd = this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg);
-	                if (axd > bestAxDiff) {
-	                    bestAxDiff = axd;
-	                    best = c;
-	                }
+	    geometryAtXY(x, y) {
+	        const { u, v } = this.toLocalUV(x, y);
+	        const cu = this.curvature(this.r_axis);
+	        const cv = this.curvature(this.r_perp);
+	        if (!Number.isFinite(cu) || !Number.isFinite(cv))
+	            return null;
+	        // biconic(conic=0) sag 식
+	        const a = cu * u * u + cv * v * v;
+	        const b = 1 - cu * cu * u * u - cv * cv * v * v;
+	        if (b < -1e-6)
+	            return null; // 루트 내부가 음수면 정의역 밖
+	        const sqrtB = Math.sqrt(Math.max(0, b));
+	        const den = 1 + sqrtB;
+	        if (Math.abs(den) < EPSILON || Math.abs(sqrtB) < EPSILON)
+	            return null;
+	        const sag = a / den;
+	        // sag 미분 계산
+	        const dAdu = 2 * cu * u;
+	        const dAdv = 2 * cv * v;
+	        const dSqrtBdu = (-(cu * cu) * u) / sqrtB;
+	        const dSqrtBdv = (-(cv * cv) * v) / sqrtB;
+	        const denSq = den * den;
+	        const dZdu = (dAdu * den - a * dSqrtBdu) / denSq;
+	        const dZdv = (dAdv * den - a * dSqrtBdv) / denSq;
+	        const { dzdx, dzdy } = this.localDerivativesToWorld(dZdu, dZdv);
+	        const normal = new Vector3(-dzdx, -dzdy, 1).normalize();
+	        return { sag, dzdx, dzdy, normal };
+	    }
+	    incident(ray) {
+	        const origin = this.worldPointToLocal(ray.endPoint());
+	        const direction = this.worldDirToLocal(ray.getDirection().normalize());
+	        // 시작점이 이미 표면 위라면 재계산 없이 바로 반환합니다.
+	        const geometryAtOrigin = this.geometryAtXY(origin.x, origin.y);
+	        if (geometryAtOrigin) {
+	            const f0 = origin.z - geometryAtOrigin.sag;
+	            if (Math.abs(f0) <= TORIC_ON_SURFACE_TOL_MM) {
+	                this.incidentRays.push(ray.clone());
+	                return origin.clone();
 	            }
-	            if (best && bestAxDiff >= lastResortMinDeg)
-	                second = best;
-	        }
-	        // 평탄도 정렬 풀만으로는 같은 phasor만 연속으로 나오는 경우가 있어, 전 스캔에서 가장 반대인 phasor를 고른다.
-	        if (!second) {
-	            let best = null;
-	            let bestDot = 1;
-	            for (const c of allSlices) {
-	                if (c === first || !depthOk(c))
-	                    continue;
-	                const d = this.phasorDot(first.profile, c.profile);
-	                if (d < bestDot) {
-	                    bestDot = d;
-	                    best = c;
-	                }
+	            // 동일 z 근처의 연속 표면에서 앞면이 origin을 약간 밀어냈을 때를 허용합니다.
+	            if (f0 > 0
+	                && f0 <= TORIC_COINCIDENT_SURFACE_TOL_MM
+	                && direction.z > 0
+	                && 0 <= origin.z + TORIC_COINCIDENT_SURFACE_TOL_MM) {
+	                this.incidentRays.push(ray.clone());
+	                return origin.clone();
 	            }
-	            if (best && bestDot < -0.08)
-	                second = best;
 	        }
-	        // 마지막: 가장 납작한 슬라이스와 깊이 차가 가장 큰 “비교적 납작한” 슬라이스 (선초점이 z로 분리될 때)
-	        if (!second) {
-	            const flatThreshold = first.ratio * 1.5 + 1e-6;
-	            let best = null;
-	            let bestDepthSpan = -1;
-	            for (const c of allSlices) {
-	                if (c === first || !depthOk(c))
-	                    continue;
-	                if (c.ratio > flatThreshold)
-	                    continue;
-	                const span = Math.abs(c.depth - first.depth);
-	                if (span > bestDepthSpan) {
-	                    bestDepthSpan = span;
-	                    best = c;
-	                }
+	        // z-plane 기준 초기 seed 이후 뉴턴법으로 교점 t를 수렴시킵니다.
+	        let t = Math.max(TORIC_MIN_T_MM, -origin.z);
+	        for (let i = 0; i < TORIC_MAX_ITERS; i++) {
+	            const p = origin.clone().addScaledVector(direction, t);
+	            const geometry = this.geometryAtXY(p.x, p.y);
+	            if (!geometry)
+	                return null;
+	            const f = p.z - geometry.sag;
+	            const df = direction.z - geometry.dzdx * direction.x - geometry.dzdy * direction.y;
+	            if (!Number.isFinite(df) || Math.abs(df) < EPSILON)
+	                return null;
+	            const dt = f / df;
+	            t -= dt;
+	            if (!Number.isFinite(t) || t < TORIC_MIN_T_MM)
+	                return null;
+	            if (Math.abs(dt) < 1e-8) {
+	                const hitPoint = this.localPointToWorld(origin.clone().addScaledVector(direction, t));
+	                this.incidentRays.push(ray.clone());
+	                return hitPoint;
 	            }
-	            if (best)
-	                second = best;
 	        }
-	        return second ? [first, second] : [first];
+	        return null;
 	    }
-	    buildApproxCenter(flattestTop2, smallestEllipse, preferTop2Mid) {
-	        if (flattestTop2.length <= 0)
+	    refract(ray) {
+	        const hitPoint = this.incident(ray);
+	        if (!hitPoint)
 	            return null;
-	        if (preferTop2Mid && flattestTop2.length >= 2) {
-	            const first = flattestTop2[0];
-	            const second = flattestTop2[1];
-	            return {
-	                x: (first.profile.at.x + second.profile.at.x) / 2,
-	                y: (first.profile.at.y + second.profile.at.y) / 2,
-	                z: (first.z + second.z) / 2,
-	                mode: "top2-mid",
-	            };
-	        }
-	        if (smallestEllipse) {
-	            return {
-	                x: smallestEllipse.profile.at.x,
-	                y: smallestEllipse.profile.at.y,
-	                z: smallestEllipse.z,
-	                mode: "min-size",
-	            };
+	        const geometry = this.geometryAtXY(hitPoint.x, hitPoint.y);
+	        if (!geometry)
+	            return null;
+	        // 스넬 굴절 벡터 계산
+	        const incidentDir = this.worldDirToLocal(ray.getDirection().normalize());
+	        const normalIntoSecond = geometry.normal.clone();
+	        // 법선을 입사방향과 같은 반공간으로 맞춰 2번째 매질 방향으로 정렬
+	        if (normalIntoSecond.dot(incidentDir) < 0) {
+	            normalIntoSecond.multiplyScalar(-1);
 	        }
-	        const first = flattestTop2[0];
-	        return { x: first.profile.at.x, y: first.profile.at.y, z: first.z, mode: "top1-flat" };
-	    }
-	    slicesForSturmAnalysis(sturmSlices, bounds) {
-	        if (!bounds)
-	            return sturmSlices;
-	        const zMin = bounds.zMin;
-	        const zMax = bounds.zMax;
-	        if (!Number.isFinite(zMin) || !Number.isFinite(zMax) || zMax < zMin)
-	            return sturmSlices;
-	        const bounded = sturmSlices.filter((s) => {
-	            const z = s.profile?.at?.z;
-	            return Number.isFinite(z) && z >= zMin && z <= zMax;
-	        });
-	        return bounded.length >= 2 ? bounded : sturmSlices;
-	    }
-	    groupByFraunhoferLine(rays) {
-	        const groups = new Map();
-	        for (const ray of rays) {
-	            const line = ray.getFraunhoferLine();
-	            const wavelength = ray.getWavelengthNm();
-	            const color = Number(ray.displayColor);
-	            if (!groups.has(line)) {
-	                groups.set(line, {
-	                    line,
-	                    wavelength_nm: wavelength,
-	                    color: Number.isFinite(color) ? color : null,
-	                    rays: [],
-	                });
-	            }
-	            const group = groups.get(line);
-	            if (group)
-	                group.rays.push(ray);
-	        }
-	        return [...groups.values()].sort((a, b) => this.lineOrder.indexOf(a.line) - this.lineOrder.indexOf(b.line));
-	    }
-	    analyzeSturmSlices(sturmSlices, effectiveCylinderD, profileWorldZBounds) {
-	        const top2MinGapMm = DEFAULT_STURM_TOP2_MIN_GAP_MM;
-	        const effectiveCylinderThresholdD = DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D;
-	        const preferTop2Mid = effectiveCylinderD >= effectiveCylinderThresholdD;
-	        const slicesForAnalysis = this.slicesForSturmAnalysis(sturmSlices, profileWorldZBounds ?? null);
-	        const sortedByFlatness = [...slicesForAnalysis].sort((a, b) => a.ratio - b.ratio);
-	        const flattestTop2 = sortedByFlatness.length > 0
-	            ? this.pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, slicesForAnalysis)
-	            : [];
-	        let smallestEllipse = null;
-	        for (const slice of slicesForAnalysis) {
-	            if (!smallestEllipse || slice.size < smallestEllipse.size)
-	                smallestEllipse = slice;
-	        }
-	        const approxCenter = this.buildApproxCenter(flattestTop2, smallestEllipse, preferTop2Mid);
-	        const anterior = flattestTop2[0] ?? null;
-	        const posterior = preferTop2Mid ? (flattestTop2[1] ?? null) : null;
-	        return {
-	            has_astigmatism: preferTop2Mid,
-	            method: preferTop2Mid ? "sturm-interval-midpoint" : "minimum-ellipse",
-	            anterior,
-	            posterior,
-	            approx_center: approxCenter,
-	        };
-	    }
-	}
-
-	class ApertureStopSurface extends Surface {
-	    constructor(props) {
-	        super({
-	            type: "aperture_stop",
-	            name: props.name,
-	            position: props.position,
-	            tilt: props.tilt,
-	        });
-	        this.shape = props.shape;
-	        this.radius = Math.max(0, Number(props.radius ?? 0));
-	        this.width = Math.max(0, Number(props.width ?? 0));
-	        this.height = Math.max(0, Number(props.height ?? 0));
-	    }
-	    worldQuaternion() {
-	        const tiltXRad = (this.tilt.x * Math.PI) / 180;
-	        const tiltYRad = (this.tilt.y * Math.PI) / 180;
-	        return new Quaternion().setFromEuler(new Euler(tiltXRad, tiltYRad, 0, "XYZ"));
-	    }
-	    localPointFromWorld(worldPoint) {
-	        const inverse = this.worldQuaternion().invert();
-	        return worldPoint
-	            .clone()
-	            .sub(this.position)
-	            .applyQuaternion(inverse);
-	    }
-	    surfaceNormalWorld() {
-	        return new Vector3(0, 0, 1).applyQuaternion(this.worldQuaternion()).normalize();
-	    }
-	    intersectForward(origin, direction) {
-	        const normal = this.surfaceNormalWorld();
-	        const denom = normal.dot(direction);
-	        if (Math.abs(denom) < EPSILON)
-	            return null;
-	        const t = normal.dot(this.position.clone().sub(origin)) / denom;
-	        if (!Number.isFinite(t) || t <= 1e-6)
-	            return null;
-	        return origin.clone().addScaledVector(direction, t);
-	    }
-	    isInsideAperture(hitPointWorld) {
-	        const local = this.localPointFromWorld(hitPointWorld);
-	        if (this.shape === "circle") {
-	            if (this.radius <= 0)
-	                return false;
-	            return Math.hypot(local.x, local.y) <= this.radius + 1e-9;
-	        }
-	        if (this.width <= 0 || this.height <= 0)
-	            return false;
-	        return (Math.abs(local.x) <= (this.width / 2) + 1e-9
-	            && Math.abs(local.y) <= (this.height / 2) + 1e-9);
-	    }
-	    incident(ray) {
-	        const origin = ray.endPoint();
-	        const direction = ray.getDirection().normalize();
-	        const hitPoint = this.intersectForward(origin, direction);
-	        if (!hitPoint)
-	            return null;
-	        if (!this.isInsideAperture(hitPoint))
-	            return null;
-	        this.incidentRays.push(ray.clone());
-	        return hitPoint;
-	    }
-	    refract(ray) {
-	        const hitPoint = this.incident(ray);
-	        if (!hitPoint)
-	            return null;
-	        const direction = ray.getDirection().normalize();
-	        const passedRay = ray.clone();
-	        passedRay.appendPoint(hitPoint);
-	        passedRay.continueFrom(hitPoint.clone().addScaledVector(direction, RAY_SURFACE_ESCAPE_MM), direction);
-	        this.refractedRays.push(passedRay.clone());
-	        return passedRay;
+	        const cos1 = Math.max(-1, Math.min(1, normalIntoSecond.dot(incidentDir)));
+	        const sin1Sq = Math.max(0, 1 - cos1 * cos1);
+	        const { nBefore, nAfter } = this.refractiveIndicesForRay(ray);
+	        const sin2 = (nBefore / nAfter) * Math.sqrt(sin1Sq);
+	        // 전반사(TIR)
+	        if (sin2 > 1 + 1e-10)
+	            return null;
+	        const cos2 = Math.sqrt(Math.max(0, 1 - sin2 * sin2));
+	        const tangent = incidentDir.clone().sub(normalIntoSecond.clone().multiplyScalar(cos1));
+	        const outDirectionLocal = tangent.lengthSq() < 1e-12
+	            ? incidentDir.clone()
+	            : normalIntoSecond
+	                .clone()
+	                .multiplyScalar(cos2)
+	                .add(tangent.normalize().multiplyScalar(sin2))
+	                .normalize();
+	        const outDirection = this.localDirToWorld(outDirectionLocal);
+	        const refractedRay = ray.clone();
+	        refractedRay.appendPoint(hitPoint);
+	        refractedRay.continueFrom(hitPoint.clone().addScaledVector(outDirection, RAY_SURFACE_ESCAPE_MM), outDirection);
+	        this.refractedRays.push(refractedRay.clone());
+	        return refractedRay;
 	    }
 	}
 
-	const DegToTABO = (degree) => {
-	    const d = Number(degree);
-	    if (!Number.isFinite(d))
-	        return 0;
-	    return (((180 - d) % 180) + 180) % 180;
-	};
-
-	class ToricSurface extends Surface {
+	class STSurface extends Surface {
 	    constructor(props) {
-	        super({ type: "toric", name: props.name, position: props.position, tilt: props.tilt });
-	        this.r_axis = 0;
-	        this.r_perp = 0;
+	        super({ type: "compound", name: props.name, position: props.position, tilt: props.tilt });
+	        this.s = 0;
+	        this.c = 0;
+	        this.ax = 0;
 	        this.n_before = 1.0;
+	        this.n = 1.0;
 	        this.n_after = 1.0;
-	        this.axisDeg = 0;
-	        const { r_axis, r_perp, axis_deg = 0, n_before = 1.0, n_after = 1.0 } = props;
-	        this.r_axis = r_axis;
-	        this.r_perp = r_perp;
-	        this.axisDeg = axis_deg;
+	        this.thickness = 0;
+	        this.sphericalRadiusMm = Number.POSITIVE_INFINITY;
+	        this.toricRadiusPerpMm = Number.POSITIVE_INFINITY;
+	        const { s, c, ax, n_before = 1.0, n = 1.0, n_after = n_before, referencePoint, thickness = ST_DEFAULT_THICKNESS_MM, } = props;
+	        this.s = s;
+	        this.c = c;
+	        // paraxial-surface와 동일: 처방 축은 TABO(°), 굴절/기하에는 수학 좌표 각(0~180)로 변환해 저장한다.
+	        this.ax = DegToTABO(ax);
 	        this.n_before = normalizeRefractiveIndexSpec(n_before);
+	        this.n = normalizeRefractiveIndexSpec(n);
 	        this.n_after = normalizeRefractiveIndexSpec(n_after);
+	        const hasToric = Math.abs(this.c) >= ST_POWER_EPS_D;
+	        // Radius must be computed with the same media pair that each sub-surface actually uses.
+	        // - toric: n_before -> n
+	        // - spherical: n -> n_after when toric exists, else n_before -> n
+	        this.toricRadiusPerpMm = this.radiusFromPower(this.c, this.refractiveIndexAtD(this.n_before), this.refractiveIndexAtD(this.n));
+	        this.sphericalRadiusMm = this.radiusFromPower(this.s, hasToric ? this.refractiveIndexAtD(this.n) : this.refractiveIndexAtD(this.n_before), hasToric ? this.refractiveIndexAtD(this.n_after) : this.refractiveIndexAtD(this.n));
+	        const requestedThickness = Math.max(0, thickness);
+	        this.thickness = requestedThickness === 0
+	            ? this.optimizeThickness(0)
+	            : requestedThickness;
+	        this.position.z = this.optimizeToricVertexZFromReference(this.position.z, referencePoint?.z, this.thickness);
+	        // 복합면: 작은 z에 토릭, 큰 z에 구면(+z 광축 기준 토릭 → 구면 순).
+	        this.sphericalSurface = this.buildSphericalSurface();
+	        this.toricSurface = this.buildToricSurface();
+	        this.prismVector = prismVectorFromClinicalBase(props.p, props.p_ax);
 	    }
-	    refractiveIndicesForRay(ray) {
-	        const line = ray.getFraunhoferLine();
-	        return {
-	            nBefore: resolveRefractiveIndex(this.n_before, line),
-	            nAfter: resolveRefractiveIndex(this.n_after, line),
-	        };
+	    pushRefractedWithPrism(ray) {
+	        const out = applyPrismVectorToRay(ray, this.prismVector);
+	        this.refractedRays.push(out.clone());
+	        return out;
 	    }
 	    /**
-	     * Toric 면의 축(meridian) 회전을 위해 사용하는 삼각함수 값입니다.
-	     * 축(axis) 회전은 axisDeg(도 단위)를 사용합니다.
+	     * 디옵터(D)로부터 반경(mm)을 계산합니다.
+	     *
+	     * power(D) = (n2 - n1) / R(m)
+	     *   -> R(mm) = 1000 * (n2 - n1) / power(D)
+	     *
+	     * 굴절력이 사실상 0이면 평면으로 간주하기 위해 +Infinity를 반환합니다.
 	     */
-	    axisTrig() {
-	        const rad = (this.axisDeg * Math.PI) / 180;
-	        return { c: Math.cos(rad), s: Math.sin(rad) };
-	    }
-	    worldQuaternion() {
-	        const tiltXRad = (this.tilt.x * Math.PI) / 180;
-	        const tiltYRad = (this.tilt.y * Math.PI) / 180;
-	        return new Quaternion().setFromEuler(new Euler(tiltXRad, tiltYRad, 0, "XYZ"));
-	    }
-	    worldPointToLocal(worldPoint) {
-	        const inverse = this.worldQuaternion().invert();
-	        return worldPoint.clone().sub(this.position).applyQuaternion(inverse);
-	    }
-	    localPointToWorld(localPoint) {
-	        return localPoint.clone().applyQuaternion(this.worldQuaternion()).add(this.position);
-	    }
-	    worldDirToLocal(worldDirection) {
-	        const inverse = this.worldQuaternion().invert();
-	        return worldDirection.clone().applyQuaternion(inverse).normalize();
-	    }
-	    localDirToWorld(localDirection) {
-	        return localDirection.clone().applyQuaternion(this.worldQuaternion()).normalize();
+	    radiusFromPower(powerD, nBefore, nAfter) {
+	        if (!Number.isFinite(powerD)
+	            || !Number.isFinite(nBefore)
+	            || !Number.isFinite(nAfter)) {
+	            return Number.NaN;
+	        }
+	        if (Math.abs(powerD) < ST_POWER_EPS_D)
+	            return Number.POSITIVE_INFINITY;
+	        return (1000 * (nAfter - nBefore)) / powerD;
 	    }
-	    /**
-	     * 월드 좌표계 (x, y)를 토릭 로컬 좌표계 (u, v)로 변환합니다.
-	     * - u: 축 방향 meridian
-	     * - v: 축에 수직인 meridian
-	     */
-	    toLocalUV(x, y) {
-	        const { c, s } = this.axisTrig();
-	        return {
-	            u: c * x + s * y,
-	            v: -s * x + c * y,
-	        };
+	    refractiveIndexAtD(spec) {
+	        return resolveRefractiveIndex(spec, "d");
 	    }
 	    /**
-	     * 로컬 좌표계에서 계산한 sag 미분(dz/du, dz/dv)을
-	     * 월드 좌표계의 기울기(dz/dx, dz/dy)로 다시 매핑합니다.
+	     * ST 구면 측: z가 더 큰 꼭지( +z 진행 시 출사 쪽 ).
 	     */
-	    localDerivativesToWorld(dZdu, dZdv) {
-	        const { c, s } = this.axisTrig();
-	        return {
-	            dzdx: dZdu * c - dZdv * s,
-	            dzdy: dZdu * s + dZdv * c,
+	    buildSphericalSurface() {
+	        const sphericalZ = this.position.z + this.thickness;
+	        const hasToric = Math.abs(this.c) >= ST_POWER_EPS_D;
+	        const nBefore = hasToric ? this.n : this.n_before;
+	        const nAfter = hasToric ? this.n_after : this.n;
+	        const props = {
+	            type: "spherical",
+	            name: `${this.name}_spherical`,
+	            position: { x: this.position.x, y: this.position.y, z: sphericalZ },
+	            tilt: { x: this.tilt.x, y: this.tilt.y },
+	            r: this.sphericalRadiusMm,
+	            n_before: nBefore,
+	            n_after: nAfter,
 	        };
+	        return new SphericalSurface(props);
 	    }
 	    /**
-	     * 반경으로부터 곡률(1/R)을 계산합니다.
-	     * - 반경이 너무 크거나 무한대면 평면으로 간주하여 0 반환
-	     * - 반경이 0에 너무 가까우면 비정상 값으로 NaN 반환
+	     * ST 토릭 측: cylinder가 있을 때만. z가 더 작은 꼭지( +z 진행 시 입사 쪽 ).
 	     */
-	    curvature(radius) {
-	        if (!Number.isFinite(radius) || Math.abs(radius) > 1e12)
-	            return 0;
-	        if (Math.abs(radius) < EPSILON)
+	    buildToricSurface() {
+	        if (Math.abs(this.c) < ST_POWER_EPS_D)
+	            return null;
+	        const props = {
+	            type: "toric",
+	            name: `${this.name}_toric`,
+	            position: {
+	                x: this.position.x,
+	                y: this.position.y,
+	                z: this.position.z,
+	            },
+	            tilt: { x: this.tilt.x, y: this.tilt.y },
+	            r_axis: Number.POSITIVE_INFINITY,
+	            r_perp: this.toricRadiusPerpMm,
+	            axis_deg: this.ax,
+	            n_before: this.n_before,
+	            n_after: this.n,
+	        };
+	        return new ToricSurface(props);
+	    }
+	    applyChromaticIndicesToSubSurfaces(ray) {
+	        const line = ray.getFraunhoferLine();
+	        const nBefore = resolveRefractiveIndex(this.n_before, line);
+	        const n = resolveRefractiveIndex(this.n, line);
+	        const nAfter = resolveRefractiveIndex(this.n_after, line);
+	        const sphericalState = this.sphericalSurface;
+	        if (this.toricSurface) {
+	            sphericalState.n_before = n;
+	            sphericalState.n_after = nAfter;
+	            const toricState = this.toricSurface;
+	            toricState.n_before = nBefore;
+	            toricState.n_after = n;
+	            return;
+	        }
+	        sphericalState.n_before = nBefore;
+	        sphericalState.n_after = n;
+	    }
+	    /**
+	     * 구면/토릭 곡면의 z 교차(토릭이 구면을 관통) 방지를 위해
+	     * 샘플링 영역에서 필요한 최소 중심두께를 계산합니다.
+	     */
+	    optimizeThickness(requestedThickness) {
+	        if (Math.abs(this.c) < ST_POWER_EPS_D)
+	            return requestedThickness;
+	        const sampleRadius = this.samplingRadiusMm();
+	        if (!Number.isFinite(sampleRadius) || sampleRadius <= 0)
+	            return requestedThickness;
+	        const samplesPerAxis = 49;
+	        let requiredThickness = requestedThickness;
+	        const safetyMargin = Math.max(0.05, 2 * RAY_SURFACE_ESCAPE_MM);
+	        for (let iy = 0; iy < samplesPerAxis; iy++) {
+	            const y = -sampleRadius + (2 * sampleRadius * iy) / (samplesPerAxis - 1);
+	            for (let ix = 0; ix < samplesPerAxis; ix++) {
+	                const x = -sampleRadius + (2 * sampleRadius * ix) / (samplesPerAxis - 1);
+	                if ((x * x + y * y) > sampleRadius * sampleRadius)
+	                    continue;
+	                const sphericalSag = this.sphericalSagAtXY(x, y);
+	                const toricSag = this.toricSagAtXY(x, y);
+	                if (!Number.isFinite(sphericalSag) || !Number.isFinite(toricSag))
+	                    continue;
+	                const localRequired = (sphericalSag - toricSag) + safetyMargin;
+	                if (localRequired > requiredThickness)
+	                    requiredThickness = localRequired;
+	            }
+	        }
+	        return Math.max(0, requiredThickness);
+	    }
+	    /**
+	     * 기준점(referencePoint.z)으로부터 토릭 꼭지(z)까지의 최소 간격을 확보합니다.
+	     * - 기준점과 반대 방향으로 현재 토릭 꼭지가 놓인 쪽(sign)을 유지합니다.
+	     * - 최소 간격은 "토릭–구면 거리(thickness) + 안전여유"입니다.
+	     */
+	    optimizeToricVertexZFromReference(toricVertexZ, referenceZ, thicknessMm = this.thickness) {
+	        if (!Number.isFinite(referenceZ))
+	            return toricVertexZ;
+	        const safetyMargin = Math.max(0.05, 2 * RAY_SURFACE_ESCAPE_MM);
+	        const minGap = Math.max(EYE_ST_SURFACE_OFFSET_MM, Math.max(0, thicknessMm) + safetyMargin);
+	        const delta = toricVertexZ - referenceZ;
+	        const side = Math.abs(delta) < 1e-12 ? -1 : Math.sign(delta);
+	        const currentGap = Math.abs(delta);
+	        if (currentGap >= minGap)
+	            return toricVertexZ;
+	        return referenceZ + side * minGap;
+	    }
+	    samplingRadiusMm() {
+	        const defaultRadius = 12;
+	        const finiteRadii = [this.sphericalRadiusMm, this.toricRadiusPerpMm]
+	            .filter((r) => Number.isFinite(r) && Math.abs(r) > 1e-6)
+	            .map((r) => Math.abs(r));
+	        if (!finiteRadii.length)
+	            return defaultRadius;
+	        return Math.max(1.0, Math.min(defaultRadius, 0.98 * Math.min(...finiteRadii)));
+	    }
+	    /**
+	     * 구면 측 꼭지점 기준 sag(mm)
+	     */
+	    sphericalSagAtXY(x, y) {
+	        const rhoSq = x * x + y * y;
+	        const r = this.sphericalRadiusMm;
+	        if (!Number.isFinite(r) || Math.abs(r) > 1e12)
+	            return 0;
+	        const rr = r * r;
+	        if (rhoSq > rr)
 	            return Number.NaN;
-	        return 1 / radius;
+	        const root = Math.sqrt(Math.max(0, rr - rhoSq));
+	        return r > 0 ? r - root : r + root;
 	    }
 	    /**
-	     * 주어진 XY에서 토릭면의 기하정보를 계산합니다.
-	     * - sag: 꼭지점 대비 z 높이
-	     * - dzdx/dzdy: 면 기울기
-	     * - normal: 2번째 매질 방향을 만들 때 사용할 기본 법선
+	     * 토릭 측 꼭지점 기준 sag(mm)
 	     */
-	    geometryAtXY(x, y) {
-	        const { u, v } = this.toLocalUV(x, y);
-	        const cu = this.curvature(this.r_axis);
-	        const cv = this.curvature(this.r_perp);
-	        if (!Number.isFinite(cu) || !Number.isFinite(cv))
-	            return null;
-	        // biconic(conic=0) sag 식
+	    toricSagAtXY(x, y) {
+	        const axisRad = (this.ax * Math.PI) / 180;
+	        const cAxis = Math.cos(axisRad);
+	        const sAxis = Math.sin(axisRad);
+	        const u = cAxis * x + sAxis * y;
+	        const v = -sAxis * x + cAxis * y;
+	        const cu = 0; // r_axis = Infinity
+	        const cv = (!Number.isFinite(this.toricRadiusPerpMm) || Math.abs(this.toricRadiusPerpMm) > 1e12)
+	            ? 0
+	            : 1 / this.toricRadiusPerpMm;
 	        const a = cu * u * u + cv * v * v;
 	        const b = 1 - cu * cu * u * u - cv * cv * v * v;
-	        if (b < -1e-6)
-	            return null; // 루트 내부가 음수면 정의역 밖
-	        const sqrtB = Math.sqrt(Math.max(0, b));
-	        const den = 1 + sqrtB;
-	        if (Math.abs(den) < EPSILON || Math.abs(sqrtB) < EPSILON)
-	            return null;
-	        const sag = a / den;
-	        // sag 미분 계산
-	        const dAdu = 2 * cu * u;
-	        const dAdv = 2 * cv * v;
-	        const dSqrtBdu = (-(cu * cu) * u) / sqrtB;
-	        const dSqrtBdv = (-(cv * cv) * v) / sqrtB;
-	        const denSq = den * den;
-	        const dZdu = (dAdu * den - a * dSqrtBdu) / denSq;
-	        const dZdv = (dAdv * den - a * dSqrtBdv) / denSq;
-	        const { dzdx, dzdy } = this.localDerivativesToWorld(dZdu, dZdv);
-	        const normal = new Vector3(-dzdx, -dzdy, 1).normalize();
-	        return { sag, dzdx, dzdy, normal };
+	        if (b < 0)
+	            return Number.NaN;
+	        const den = 1 + Math.sqrt(Math.max(0, b));
+	        if (Math.abs(den) < 1e-12)
+	            return Number.NaN;
+	        return a / den;
 	    }
-	    incident(ray) {
-	        const origin = this.worldPointToLocal(ray.endPoint());
-	        const direction = this.worldDirToLocal(ray.getDirection().normalize());
-	        // 시작점이 이미 표면 위라면 재계산 없이 바로 반환합니다.
-	        const geometryAtOrigin = this.geometryAtXY(origin.x, origin.y);
-	        if (geometryAtOrigin) {
-	            const f0 = origin.z - geometryAtOrigin.sag;
-	            if (Math.abs(f0) <= TORIC_ON_SURFACE_TOL_MM) {
-	                this.incidentRays.push(ray.clone());
-	                return origin.clone();
-	            }
-	            // 동일 z 근처의 연속 표면에서 앞면이 origin을 약간 밀어냈을 때를 허용합니다.
-	            if (f0 > 0
-	                && f0 <= TORIC_COINCIDENT_SURFACE_TOL_MM
-	                && direction.z > 0
-	                && 0 <= origin.z + TORIC_COINCIDENT_SURFACE_TOL_MM) {
-	                this.incidentRays.push(ray.clone());
-	                return origin.clone();
+	    isOpticallyNeutral() {
+	        return (Math.abs(Number(this.s) || 0) < STSurface.POWER_EPS_D
+	            && Math.abs(Number(this.c) || 0) < STSurface.POWER_EPS_D);
+	    }
+	    refract(ray) {
+	        // 무도수 ST면은 기하(면 위치/경사)는 유지하되 굴절력은 0으로 취급하여 직진 통과시킵니다.
+	        if (this.isOpticallyNeutral()) {
+	            const direction = ray.getDirection().normalize();
+	            const passthrough = ray.clone();
+	            const hitPoint = this.sphericalSurface.incident(ray);
+	            if (hitPoint) {
+	                passthrough.appendPoint(hitPoint);
+	                passthrough.continueFrom(hitPoint.clone().addScaledVector(direction, RAY_SURFACE_ESCAPE_MM), direction);
 	            }
+	            return this.pushRefractedWithPrism(passthrough);
 	        }
-	        // z-plane 기준 초기 seed 이후 뉴턴법으로 교점 t를 수렴시킵니다.
-	        let t = Math.max(TORIC_MIN_T_MM, -origin.z);
-	        for (let i = 0; i < TORIC_MAX_ITERS; i++) {
-	            const p = origin.clone().addScaledVector(direction, t);
-	            const geometry = this.geometryAtXY(p.x, p.y);
-	            if (!geometry)
-	                return null;
-	            const f = p.z - geometry.sag;
-	            const df = direction.z - geometry.dzdx * direction.x - geometry.dzdy * direction.y;
-	            if (!Number.isFinite(df) || Math.abs(df) < EPSILON)
-	                return null;
-	            const dt = f / df;
-	            t -= dt;
-	            if (!Number.isFinite(t) || t < TORIC_MIN_T_MM)
+	        this.applyChromaticIndicesToSubSurfaces(ray);
+	        // 원통 성분이 없으면 단일(구면)면으로 처리합니다.
+	        if (!this.toricSurface) {
+	            const single = this.sphericalSurface.refract(ray);
+	            if (!single)
 	                return null;
-	            if (Math.abs(dt) < 1e-8) {
-	                const hitPoint = this.localPointToWorld(origin.clone().addScaledVector(direction, t));
-	                this.incidentRays.push(ray.clone());
-	                return hitPoint;
-	            }
+	            return this.pushRefractedWithPrism(single);
 	        }
-	        return null;
-	    }
-	    refract(ray) {
-	        const hitPoint = this.incident(ray);
-	        if (!hitPoint)
+	        // +z 진행: 토릭(작은 z) → 구면(큰 z)
+	        const afterToric = this.toricSurface.refract(ray);
+	        if (!afterToric)
 	            return null;
-	        const geometry = this.geometryAtXY(hitPoint.x, hitPoint.y);
-	        if (!geometry)
+	        const afterSpherical = this.sphericalSurface.refract(afterToric);
+	        if (!afterSpherical)
 	            return null;
-	        // 스넬 굴절 벡터 계산
-	        const incidentDir = this.worldDirToLocal(ray.getDirection().normalize());
-	        const normalIntoSecond = geometry.normal.clone();
-	        // 법선을 입사방향과 같은 반공간으로 맞춰 2번째 매질 방향으로 정렬
-	        if (normalIntoSecond.dot(incidentDir) < 0) {
-	            normalIntoSecond.multiplyScalar(-1);
-	        }
-	        const cos1 = Math.max(-1, Math.min(1, normalIntoSecond.dot(incidentDir)));
-	        const sin1Sq = Math.max(0, 1 - cos1 * cos1);
-	        const { nBefore, nAfter } = this.refractiveIndicesForRay(ray);
-	        const sin2 = (nBefore / nAfter) * Math.sqrt(sin1Sq);
-	        // 전반사(TIR)
-	        if (sin2 > 1 + 1e-10)
+	        return this.pushRefractedWithPrism(afterSpherical);
+	    }
+	    incident(ray) {
+	        // 복합면의 첫 hit: +z 기준 토릭이 앞서므로 toricSurface 우선.
+	        const primary = this.toricSurface ?? this.sphericalSurface;
+	        const hitPoint = primary.incident(ray);
+	        if (!hitPoint)
 	            return null;
-	        const cos2 = Math.sqrt(Math.max(0, 1 - sin2 * sin2));
-	        const tangent = incidentDir.clone().sub(normalIntoSecond.clone().multiplyScalar(cos1));
-	        const outDirectionLocal = tangent.lengthSq() < 1e-12
-	            ? incidentDir.clone()
-	            : normalIntoSecond
-	                .clone()
-	                .multiplyScalar(cos2)
-	                .add(tangent.normalize().multiplyScalar(sin2))
-	                .normalize();
-	        const outDirection = this.localDirToWorld(outDirectionLocal);
-	        const refractedRay = ray.clone();
-	        refractedRay.appendPoint(hitPoint);
-	        refractedRay.continueFrom(hitPoint.clone().addScaledVector(outDirection, RAY_SURFACE_ESCAPE_MM), outDirection);
-	        this.refractedRays.push(refractedRay.clone());
-	        return refractedRay;
+	        this.incidentRays.push(ray.clone());
+	        return hitPoint;
 	    }
-	}
+	    getOptimizedThicknessMm() {
+	        return this.thickness;
+	    }
+	    applyRigidRotationAboutPivot(pivot, rotation) {
+	        const move = (p0) => pivot.clone().add(new Vector3().subVectors(p0, pivot).applyQuaternion(rotation));
+	        const euler = new Euler().setFromQuaternion(rotation, "XYZ");
+	        const tx = (euler.x * 180) / Math.PI;
+	        const ty = (euler.y * 180) / Math.PI;
+	        const newTor = move(this.position.clone());
+	        const newSph = move(this.sphericalSurface.getWorldPosition());
+	        this.setPositionAndTilt(newTor, tx, ty);
+	        this.sphericalSurface.setPositionAndTilt(newSph, tx, ty);
+	        if (this.toricSurface) {
+	            this.toricSurface.setPositionAndTilt(newTor.clone(), tx, ty);
+	        }
+	    }
+	}
+	STSurface.POWER_EPS_D = ST_POWER_EPS_D;
 
-	class STSurface extends Surface {
-	    constructor(props) {
-	        super({ type: "compound", name: props.name, position: props.position, tilt: props.tilt });
-	        this.s = 0;
-	        this.c = 0;
-	        this.ax = 0;
-	        this.n_before = 1.0;
-	        this.n = 1.0;
-	        this.n_after = 1.0;
-	        this.thickness = 0;
-	        this.sphericalRadiusMm = Number.POSITIVE_INFINITY;
-	        this.toricRadiusPerpMm = Number.POSITIVE_INFINITY;
-	        const { s, c, ax, n_before = 1.0, n = 1.0, n_after = n_before, referencePoint, thickness = ST_DEFAULT_THICKNESS_MM, } = props;
-	        this.s = s;
-	        this.c = c;
-	        // paraxial-surface와 동일: 처방 축은 TABO(°), 굴절/기하에는 수학 좌표 각(0~180)로 변환해 저장한다.
-	        this.ax = DegToTABO(ax);
-	        this.n_before = normalizeRefractiveIndexSpec(n_before);
-	        this.n = normalizeRefractiveIndexSpec(n);
-	        this.n_after = normalizeRefractiveIndexSpec(n_after);
-	        const hasToric = Math.abs(this.c) >= ST_POWER_EPS_D;
-	        // Radius must be computed with the same media pair that each sub-surface actually uses.
-	        // - toric: n_before -> n
-	        // - spherical: n -> n_after when toric exists, else n_before -> n
-	        this.toricRadiusPerpMm = this.radiusFromPower(this.c, this.refractiveIndexAtD(this.n_before), this.refractiveIndexAtD(this.n));
-	        this.sphericalRadiusMm = this.radiusFromPower(this.s, hasToric ? this.refractiveIndexAtD(this.n) : this.refractiveIndexAtD(this.n_before), hasToric ? this.refractiveIndexAtD(this.n_after) : this.refractiveIndexAtD(this.n));
-	        const requestedThickness = Math.max(0, thickness);
-	        this.thickness = requestedThickness === 0
-	            ? this.optimizeThickness(0)
-	            : requestedThickness;
-	        this.position.z = this.optimizeToricVertexZFromReference(this.position.z, referencePoint?.z, this.thickness);
-	        // 복합면: 작은 z에 토릭, 큰 z에 구면(+z 광축 기준 토릭 → 구면 순).
-	        this.sphericalSurface = this.buildSphericalSurface();
-	        this.toricSurface = this.buildToricSurface();
+	function toFiniteNumber$1(value, fallback = 0) {
+	    const parsed = Number(value);
+	    return Number.isFinite(parsed) ? parsed : fallback;
+	}
+	function normalizePrismAmount$1(value) {
+	    const p = Number(value ?? 0);
+	    return Number.isFinite(p) ? Math.max(0, p) : 0;
+	}
+	function normalizeAngle360$1(value) {
+	    const d = Number(value ?? 0);
+	    if (!Number.isFinite(d))
+	        return 0;
+	    return ((d % 360) + 360) % 360;
+	}
+	class EyeModelParameter {
+	    constructor(parameter) {
+	        this.parameter = parameter;
 	    }
 	    /**
-	     * 디옵터(D)로부터 반경(mm)을 계산합니다.
-	     *
-	     * power(D) = (n2 - n1) / R(m)
-	     *   -> R(mm) = 1000 * (n2 - n1) / power(D)
-	     *
-	     * 굴절력이 사실상 0이면 평면으로 간주하기 위해 +Infinity를 반환합니다.
+	     * 동공(선택) → eye_st(ST 복합면) → 안구 모델 해부면 순으로 생성한 뒤,
+	     * `p`/`p_ax`/`tilt`를 안구 회전점 기준 강체 회전으로 반영합니다.
 	     */
-	    radiusFromPower(powerD, nBefore, nAfter) {
-	        if (!Number.isFinite(powerD)
-	            || !Number.isFinite(nBefore)
-	            || !Number.isFinite(nAfter)) {
-	            return Number.NaN;
+	    createSurface(eye) {
+	        const normalizedEyeSphere = toFiniteNumber$1(eye.s) + (eye.eyeModel === "gullstrand" ? -1 : 0);
+	        const eyePower = {
+	            s: -normalizedEyeSphere,
+	            c: -toFiniteNumber$1(eye.c),
+	            ax: toFiniteNumber$1(eye.ax),
+	        };
+	        const pNorm = normalizePrismAmount$1(eye.p);
+	        const pAxNorm = normalizeAngle360$1(eye.p_ax);
+	        const tiltDeg = {
+	            x: toFiniteNumber$1(eye.tilt?.x),
+	            y: toFiniteNumber$1(eye.tilt?.y),
+	        };
+	        const rotation = eyePrismAndTiltToQuaternion(pNorm, pAxNorm, tiltDeg);
+	        const eyeSt = new STSurface({
+	            type: "compound",
+	            name: "eye_st",
+	            position: { x: 0, y: 0, z: -EYE_ST_SURFACE_OFFSET_MM },
+	            referencePoint: { x: 0, y: 0, z: 0 },
+	            tilt: { x: 0, y: 0 },
+	            s: eyePower.s,
+	            c: eyePower.c,
+	            ax: eyePower.ax,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            n: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	        });
+	        const anatomical = this.parameter.surfaces.map((surface) => {
+	            if (surface.type === "spherical") {
+	                return new SphericalSurface({
+	                    type: "spherical",
+	                    name: surface.name,
+	                    r: surface.radius,
+	                    position: { x: 0, y: 0, z: surface.z },
+	                    tilt: { x: 0, y: 0 },
+	                    n_before: surface.n_before,
+	                    n_after: surface.n_after,
+	                });
+	            }
+	            if (surface.type === "aspherical") {
+	                return new AsphericalSurface({
+	                    type: "aspherical",
+	                    name: surface.name,
+	                    position: { x: 0, y: 0, z: surface.z },
+	                    tilt: { x: 0, y: 0 },
+	                    r: surface.radius,
+	                    conic: surface.conic,
+	                    n_before: surface.n_before,
+	                    n_after: surface.n_after,
+	                });
+	            }
+	            if (surface.type === "spherical-image") {
+	                return new SphericalImageSurface({
+	                    type: "spherical-image",
+	                    name: surface.name,
+	                    r: surface.radius,
+	                    position: { x: 0, y: 0, z: surface.z },
+	                    tilt: { x: 0, y: 0 },
+	                    retina_extra_after: true,
+	                });
+	            }
+	            throw new Error(`Unsupported surface type: ${surface.type}`);
+	        });
+	        const surfaces = [eyeSt, ...anatomical];
+	        const pupilMm = toFiniteNumber$1(eye.pupilDiameterMm);
+	        if (Number.isFinite(pupilMm) && pupilMm > 0) {
+	            const pupilStop = new ApertureStopSurface({
+	                type: "aperture_stop",
+	                name: "pupil_stop",
+	                shape: "circle",
+	                radius: pupilMm / 2,
+	                position: {
+	                    x: 0,
+	                    y: 0,
+	                    z: -EYE_ST_SURFACE_OFFSET_MM - (2 * RAY_SURFACE_ESCAPE_MM),
+	                },
+	                tilt: { x: 0, y: 0 },
+	            });
+	            surfaces.unshift(pupilStop);
 	        }
-	        if (Math.abs(powerD) < ST_POWER_EPS_D)
-	            return Number.POSITIVE_INFINITY;
-	        return (1000 * (nAfter - nBefore)) / powerD;
+	        applyRigidEyePoseToSurfaces(surfaces, eyeRotationPivot(), rotation);
+	        return surfaces;
 	    }
-	    refractiveIndexAtD(spec) {
-	        return resolveRefractiveIndex(spec, "d");
+	}
+
+	class GullstrandParameter extends EyeModelParameter {
+	    constructor() {
+	        super(GullstrandParameter.parameter);
 	    }
-	    /**
-	     * ST 구면 측: z가 더 큰 꼭지( +z 진행 시 출사 쪽 ).
-	     */
-	    buildSphericalSurface() {
-	        const sphericalZ = this.position.z + this.thickness;
-	        const hasToric = Math.abs(this.c) >= ST_POWER_EPS_D;
-	        const nBefore = hasToric ? this.n : this.n_before;
-	        const nAfter = hasToric ? this.n_after : this.n;
-	        const props = {
+	}
+	GullstrandParameter.parameter = {
+	    unit: "mm",
+	    axis: "optical_axis_z",
+	    origin: "cornea_anterior_vertex",
+	    surfaces: [
+	        {
 	            type: "spherical",
-	            name: `${this.name}_spherical`,
-	            position: { x: this.position.x, y: this.position.y, z: sphericalZ },
-	            tilt: { x: this.tilt.x, y: this.tilt.y },
-	            r: this.sphericalRadiusMm,
-	            n_before: nBefore,
-	            n_after: nAfter,
+	            name: "cornea_anterior",
+	            z: 0.0,
+	            radius: 7.7,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	        },
+	        {
+	            type: "spherical",
+	            name: "cornea_posterior",
+	            z: 0.5,
+	            radius: 6.8,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	        },
+	        {
+	            type: "spherical",
+	            name: "lens_anterior",
+	            z: 3.6,
+	            radius: 10.0,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
+	        },
+	        {
+	            type: "spherical",
+	            name: "lens_nucleus_anterior",
+	            z: 4.146,
+	            radius: 7.911,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_anterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
+	        },
+	        {
+	            type: "spherical",
+	            name: "lens_nucleus_posterior",
+	            z: 6.565,
+	            radius: -5.76,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_anterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
+	        },
+	        {
+	            type: "spherical",
+	            name: "lens_posterior",
+	            z: 7.2,
+	            radius: -6,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_nucleus_posterior,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
+	        },
+	        {
+	            type: "spherical-image",
+	            name: "retina",
+	            radius: -12, // mm (대략적인 망막 곡률)
+	            z: 24.0 // 중심 위치
+	        }
+	    ],
+	};
+
+	class NavarroParameter extends EyeModelParameter {
+	    constructor() {
+	        super(NavarroParameter.parameter);
+	    }
+	}
+	NavarroParameter.parameter = {
+	    unit: "mm",
+	    axis: "optical_axis_z",
+	    surfaces: [
+	        {
+	            type: "aspherical",
+	            name: "cornea_anterior",
+	            z: 0.0,
+	            radius: 7.72,
+	            conic: -0.26,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	        },
+	        {
+	            type: "aspherical",
+	            name: "cornea_posterior",
+	            z: 0.55,
+	            radius: 6.5,
+	            conic: 0.0,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	        },
+	        {
+	            type: "aspherical",
+	            name: "lens_anterior",
+	            z: 0.55 + 3.05,
+	            radius: 10.2,
+	            conic: -3.13,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
+	        },
+	        {
+	            type: "aspherical",
+	            name: "lens_posterior",
+	            z: 0.55 + 3.05 + 4.0,
+	            radius: -6,
+	            conic: -1,
+	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.lens_navarro,
+	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.vitreous,
+	        },
+	        {
+	            type: "spherical-image",
+	            name: "retina",
+	            radius: -12, // mm (대략적인 망막 곡률)
+	            z: 24.04 // 중심 위치
+	        }
+	    ],
+	};
+
+	/**
+	 * Sturm 계산 전용 클래스입니다.
+	 * - traced ray 집합에서 z-scan slice를 생성하고
+	 * - 평탄도/최소타원/근사중심을 계산해 분석 결과를 반환합니다.
+	 */
+	class Sturm {
+	    constructor() {
+	        this.lastResult = null;
+	        this.lineOrder = ["g", "F", "e", "d", "C", "r"];
+	    }
+	    calculate(rays, effectiveCylinderD, axisReferenceRays, profileWorldZBounds) {
+	        const frame = this.analysisFrameFromRays(axisReferenceRays?.length ? axisReferenceRays : rays);
+	        const depthRange = this.depthRangeFromRays(rays, frame);
+	        const sturmSlices = this.collectSturmSlices(rays, frame, depthRange, DEFAULT_STURM_STEP_MM);
+	        const groupedByLine = this.groupByFraunhoferLine(rays);
+	        const sturmInfo = groupedByLine.map((group) => {
+	            const groupFrame = this.analysisFrameFromRays(group.rays, frame);
+	            const groupDepthRange = this.depthRangeFromRays(group.rays, groupFrame);
+	            const slices = this.collectSturmSlices(group.rays, groupFrame, groupDepthRange, DEFAULT_STURM_STEP_MM);
+	            const analysis = this.analyzeSturmSlices(slices, effectiveCylinderD, profileWorldZBounds);
+	            return {
+	                line: group.line,
+	                wavelength_nm: group.wavelength_nm,
+	                color: group.color,
+	                ray_count: group.rays.length,
+	                analysis_axis: {
+	                    x: groupFrame.axis.x,
+	                    y: groupFrame.axis.y,
+	                    z: groupFrame.axis.z,
+	                },
+	                ...analysis,
+	            };
+	        });
+	        const result = {
+	            slices_info: {
+	                count: sturmSlices.length,
+	                slices: sturmSlices,
+	            },
+	            sturm_info: sturmInfo,
 	        };
-	        return new SphericalSurface(props);
+	        this.lastResult = result;
+	        return result;
 	    }
 	    /**
-	     * ST 토릭 측: cylinder가 있을 때만. z가 더 작은 꼭지( +z 진행 시 입사 쪽 ).
+	     * 마지막 Sturm 계산 결과를 반환합니다.
 	     */
-	    buildToricSurface() {
-	        if (Math.abs(this.c) < ST_POWER_EPS_D)
+	    getLastResult() {
+	        return this.lastResult;
+	    }
+	    getRayPoints(ray) {
+	        const points = ray.points;
+	        return Array.isArray(points) ? points : [];
+	    }
+	    analysisFrameFromRays(rays, fallback) {
+	        const axis = new Vector3();
+	        for (const ray of rays ?? [])
+	            axis.add(ray.getDirection());
+	        if (axis.lengthSq() < 1e-12) {
+	            if (fallback)
+	                return fallback;
+	            axis.set(0, 0, 1);
+	        }
+	        else {
+	            axis.normalize();
+	        }
+	        const origin = new Vector3(0, 0, 0);
+	        let helper = new Vector3(0, 1, 0);
+	        if (Math.abs(helper.dot(axis)) > 0.95)
+	            helper = new Vector3(1, 0, 0);
+	        const u = helper.clone().cross(axis).normalize();
+	        const v = axis.clone().cross(u).normalize();
+	        return { origin, axis, u, v };
+	    }
+	    sampleRayPointAtDepth(ray, frame, depth) {
+	        const points = this.getRayPoints(ray);
+	        for (let i = 0; i < points.length - 1; i += 1) {
+	            const a = points[i];
+	            const b = points[i + 1];
+	            const da = a.clone().sub(frame.origin).dot(frame.axis);
+	            const db = b.clone().sub(frame.origin).dot(frame.axis);
+	            if ((da <= depth && depth <= db) || (db <= depth && depth <= da)) {
+	                const denom = db - da;
+	                if (Math.abs(denom) < 1e-10)
+	                    return null;
+	                return a.clone().lerp(b, (depth - da) / denom);
+	            }
+	        }
+	        return null;
+	    }
+	    depthRangeFromRays(rays, frame) {
+	        let depthMin = Number.POSITIVE_INFINITY;
+	        let depthMax = Number.NEGATIVE_INFINITY;
+	        for (const ray of rays ?? []) {
+	            for (const point of this.getRayPoints(ray)) {
+	                const d = point.clone().sub(frame.origin).dot(frame.axis);
+	                depthMin = Math.min(depthMin, d);
+	                depthMax = Math.max(depthMax, d);
+	            }
+	        }
+	        if (!Number.isFinite(depthMin) || !Number.isFinite(depthMax) || depthMax <= depthMin)
 	            return null;
-	        const props = {
-	            type: "toric",
-	            name: `${this.name}_toric`,
-	            position: {
-	                x: this.position.x,
-	                y: this.position.y,
-	                z: this.position.z,
+	        return { depthMin, depthMax };
+	    }
+	    secondMomentProfileAtDepth(rays, frame, depth) {
+	        const points = [];
+	        for (const ray of rays) {
+	            const point = this.sampleRayPointAtDepth(ray, frame, depth);
+	            if (point)
+	                points.push(point);
+	        }
+	        if (points.length < 4)
+	            return null;
+	        let cxWorld = 0;
+	        let cyWorld = 0;
+	        let czWorld = 0;
+	        let cx = 0;
+	        let cy = 0;
+	        for (const p of points) {
+	            cxWorld += p.x;
+	            cyWorld += p.y;
+	            czWorld += p.z;
+	            const delta = p.clone().sub(frame.origin);
+	            cx += delta.dot(frame.u);
+	            cy += delta.dot(frame.v);
+	        }
+	        cxWorld /= points.length;
+	        cyWorld /= points.length;
+	        czWorld /= points.length;
+	        cx /= points.length;
+	        cy /= points.length;
+	        let sxx = 0;
+	        let syy = 0;
+	        let sxy = 0;
+	        for (const p of points) {
+	            const delta = p.clone().sub(frame.origin);
+	            const x = delta.dot(frame.u);
+	            const y = delta.dot(frame.v);
+	            const dx = x - cx;
+	            const dy = y - cy;
+	            sxx += dx * dx;
+	            syy += dy * dy;
+	            sxy += dx * dy;
+	        }
+	        sxx /= points.length;
+	        syy /= points.length;
+	        sxy /= points.length;
+	        const trace = sxx + syy;
+	        const halfDiff = (sxx - syy) / 2;
+	        const root = Math.sqrt(Math.max(0, halfDiff * halfDiff + sxy * sxy));
+	        const lambdaMajor = Math.max(0, trace / 2 + root);
+	        const lambdaMinor = Math.max(0, trace / 2 - root);
+	        const thetaRad = 0.5 * Math.atan2(2 * sxy, sxx - syy);
+	        const angleMajorDeg = ((thetaRad * 180) / Math.PI + 360) % 180;
+	        const twoThetaRad = 2 * thetaRad;
+	        const j0 = Math.cos(twoThetaRad);
+	        const j45 = Math.sin(twoThetaRad);
+	        const majorDirection = frame.u.clone().multiplyScalar(Math.cos(thetaRad))
+	            .add(frame.v.clone().multiplyScalar(Math.sin(thetaRad)))
+	            .normalize();
+	        const minorDirection = frame.axis.clone().cross(majorDirection).normalize();
+	        return {
+	            at: { x: cxWorld, y: cyWorld, z: czWorld },
+	            wMajor: Math.sqrt(lambdaMajor),
+	            wMinor: Math.sqrt(lambdaMinor),
+	            angleMajorDeg,
+	            j0,
+	            j45,
+	            angleMinorDeg: (angleMajorDeg + 90) % 180,
+	            majorDirection: {
+	                x: majorDirection.x,
+	                y: majorDirection.y,
+	                z: majorDirection.z,
+	            },
+	            minorDirection: {
+	                x: minorDirection.x,
+	                y: minorDirection.y,
+	                z: minorDirection.z,
 	            },
-	            tilt: { x: this.tilt.x, y: this.tilt.y },
-	            r_axis: Number.POSITIVE_INFINITY,
-	            r_perp: this.toricRadiusPerpMm,
-	            axis_deg: this.ax,
-	            n_before: this.n_before,
-	            n_after: this.n,
 	        };
-	        return new ToricSurface(props);
 	    }
-	    applyChromaticIndicesToSubSurfaces(ray) {
-	        const line = ray.getFraunhoferLine();
-	        const nBefore = resolveRefractiveIndex(this.n_before, line);
-	        const n = resolveRefractiveIndex(this.n, line);
-	        const nAfter = resolveRefractiveIndex(this.n_after, line);
-	        const sphericalState = this.sphericalSurface;
-	        if (this.toricSurface) {
-	            sphericalState.n_before = n;
-	            sphericalState.n_after = nAfter;
-	            const toricState = this.toricSurface;
-	            toricState.n_before = nBefore;
-	            toricState.n_after = n;
-	            return;
+	    collectSturmSlices(rays, frame, depthRange, stepMm) {
+	        if (!depthRange)
+	            return [];
+	        const out = [];
+	        for (let depth = depthRange.depthMin; depth <= depthRange.depthMax; depth += stepMm) {
+	            const profile = this.secondMomentProfileAtDepth(rays, frame, depth);
+	            if (!profile)
+	                continue;
+	            out.push({
+	                // Keep z in world coordinates for backward-compatible consumers.
+	                z: profile.at.z,
+	                // Preserve analysis-axis depth for off-axis robust ranking/interval logic.
+	                depth,
+	                ratio: profile.wMinor / Math.max(profile.wMajor, 1e-9),
+	                size: Math.hypot(profile.wMajor, profile.wMinor),
+	                profile,
+	            });
 	        }
-	        sphericalState.n_before = nBefore;
-	        sphericalState.n_after = n;
+	        return out;
+	    }
+	    axisDiffDeg(a, b) {
+	        const d = Math.abs((((a - b) % 180) + 180) % 180);
+	        return Math.min(d, 180 - d);
+	    }
+	    phasorDot(p, q) {
+	        return p.j0 * q.j0 + p.j45 * q.j45;
 	    }
 	    /**
-	     * 구면/토릭 곡면의 z 교차(토릭이 구면을 관통) 방지를 위해
-	     * 샘플링 영역에서 필요한 최소 중심두께를 계산합니다.
+	     * 평탄도 순으로 정렬된 슬라이스에서 선초점 쌍(직교 주경선)에 해당하는 Top2를 고른다.
+	     * 주경선 각 대신 이각 phasor (cos 2θ, sin 2θ)로 직교를 판정하고, 실패 시 각도·전역 검색·깊이 폴백을 사용한다.
 	     */
-	    optimizeThickness(requestedThickness) {
-	        if (Math.abs(this.c) < ST_POWER_EPS_D)
-	            return requestedThickness;
-	        const sampleRadius = this.samplingRadiusMm();
-	        if (!Number.isFinite(sampleRadius) || sampleRadius <= 0)
-	            return requestedThickness;
-	        const samplesPerAxis = 49;
-	        let requiredThickness = requestedThickness;
-	        const safetyMargin = Math.max(0.05, 2 * RAY_SURFACE_ESCAPE_MM);
-	        for (let iy = 0; iy < samplesPerAxis; iy++) {
-	            const y = -sampleRadius + (2 * sampleRadius * iy) / (samplesPerAxis - 1);
-	            for (let ix = 0; ix < samplesPerAxis; ix++) {
-	                const x = -sampleRadius + (2 * sampleRadius * ix) / (samplesPerAxis - 1);
-	                if ((x * x + y * y) > sampleRadius * sampleRadius)
+	    pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, allSlices) {
+	        if (sortedByFlatness.length === 0)
+	            return [];
+	        const first = sortedByFlatness[0];
+	        const top2MinAngleGapDeg = DEFAULT_STURM_TOP2_MIN_ANGLE_GAP_DEG;
+	        const phasorStrict = DEFAULT_STURM_TOP2_PHASOR_OPPOSITION_MAX_DOT;
+	        const phasorLoose = DEFAULT_STURM_TOP2_PHASOR_FALLBACK_MAX_DOT;
+	        const lastResortMinDeg = DEFAULT_STURM_TOP2_AXIS_LAST_RESORT_MIN_GAP_DEG;
+	        const depthOk = (c) => Math.abs(c.depth - first.depth) >= top2MinGapMm;
+	        const byPhasor = (pool, maxDot) => pool.find((c) => (c !== first
+	            && depthOk(c)
+	            && this.phasorDot(first.profile, c.profile) <= maxDot));
+	        let second = byPhasor(sortedByFlatness, phasorStrict)
+	            ?? byPhasor(sortedByFlatness, phasorLoose);
+	        if (!second) {
+	            second = sortedByFlatness.find((c) => (c !== first
+	                && depthOk(c)
+	                && this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg) >= top2MinAngleGapDeg));
+	        }
+	        if (!second) {
+	            let best = null;
+	            let bestAxDiff = -1;
+	            for (const c of sortedByFlatness) {
+	                if (c === first || !depthOk(c))
 	                    continue;
-	                const sphericalSag = this.sphericalSagAtXY(x, y);
-	                const toricSag = this.toricSagAtXY(x, y);
-	                if (!Number.isFinite(sphericalSag) || !Number.isFinite(toricSag))
+	                const axd = this.axisDiffDeg(c.profile.angleMajorDeg, first.profile.angleMajorDeg);
+	                if (axd > bestAxDiff) {
+	                    bestAxDiff = axd;
+	                    best = c;
+	                }
+	            }
+	            if (best && bestAxDiff >= lastResortMinDeg)
+	                second = best;
+	        }
+	        // 평탄도 정렬 풀만으로는 같은 phasor만 연속으로 나오는 경우가 있어, 전 스캔에서 가장 반대인 phasor를 고른다.
+	        if (!second) {
+	            let best = null;
+	            let bestDot = 1;
+	            for (const c of allSlices) {
+	                if (c === first || !depthOk(c))
 	                    continue;
-	                const localRequired = (sphericalSag - toricSag) + safetyMargin;
-	                if (localRequired > requiredThickness)
-	                    requiredThickness = localRequired;
+	                const d = this.phasorDot(first.profile, c.profile);
+	                if (d < bestDot) {
+	                    bestDot = d;
+	                    best = c;
+	                }
 	            }
+	            if (best && bestDot < -0.08)
+	                second = best;
 	        }
-	        return Math.max(0, requiredThickness);
-	    }
-	    /**
-	     * 기준점(referencePoint.z)으로부터 토릭 꼭지(z)까지의 최소 간격을 확보합니다.
-	     * - 기준점과 반대 방향으로 현재 토릭 꼭지가 놓인 쪽(sign)을 유지합니다.
-	     * - 최소 간격은 "토릭–구면 거리(thickness) + 안전여유"입니다.
-	     */
-	    optimizeToricVertexZFromReference(toricVertexZ, referenceZ, thicknessMm = this.thickness) {
-	        if (!Number.isFinite(referenceZ))
-	            return toricVertexZ;
-	        const safetyMargin = Math.max(0.05, 2 * RAY_SURFACE_ESCAPE_MM);
-	        const minGap = Math.max(EYE_ST_SURFACE_OFFSET_MM, Math.max(0, thicknessMm) + safetyMargin);
-	        const delta = toricVertexZ - referenceZ;
-	        const side = Math.abs(delta) < 1e-12 ? -1 : Math.sign(delta);
-	        const currentGap = Math.abs(delta);
-	        if (currentGap >= minGap)
-	            return toricVertexZ;
-	        return referenceZ + side * minGap;
-	    }
-	    samplingRadiusMm() {
-	        const defaultRadius = 12;
-	        const finiteRadii = [this.sphericalRadiusMm, this.toricRadiusPerpMm]
-	            .filter((r) => Number.isFinite(r) && Math.abs(r) > 1e-6)
-	            .map((r) => Math.abs(r));
-	        if (!finiteRadii.length)
-	            return defaultRadius;
-	        return Math.max(1.0, Math.min(defaultRadius, 0.98 * Math.min(...finiteRadii)));
-	    }
-	    /**
-	     * 구면 측 꼭지점 기준 sag(mm)
-	     */
-	    sphericalSagAtXY(x, y) {
-	        const rhoSq = x * x + y * y;
-	        const r = this.sphericalRadiusMm;
-	        if (!Number.isFinite(r) || Math.abs(r) > 1e12)
-	            return 0;
-	        const rr = r * r;
-	        if (rhoSq > rr)
-	            return Number.NaN;
-	        const root = Math.sqrt(Math.max(0, rr - rhoSq));
-	        return r > 0 ? r - root : r + root;
-	    }
-	    /**
-	     * 토릭 측 꼭지점 기준 sag(mm)
-	     */
-	    toricSagAtXY(x, y) {
-	        const axisRad = (this.ax * Math.PI) / 180;
-	        const cAxis = Math.cos(axisRad);
-	        const sAxis = Math.sin(axisRad);
-	        const u = cAxis * x + sAxis * y;
-	        const v = -sAxis * x + cAxis * y;
-	        const cu = 0; // r_axis = Infinity
-	        const cv = (!Number.isFinite(this.toricRadiusPerpMm) || Math.abs(this.toricRadiusPerpMm) > 1e12)
-	            ? 0
-	            : 1 / this.toricRadiusPerpMm;
-	        const a = cu * u * u + cv * v * v;
-	        const b = 1 - cu * cu * u * u - cv * cv * v * v;
-	        if (b < 0)
-	            return Number.NaN;
-	        const den = 1 + Math.sqrt(Math.max(0, b));
-	        if (Math.abs(den) < 1e-12)
-	            return Number.NaN;
-	        return a / den;
+	        // 마지막: 가장 납작한 슬라이스와 깊이 차가 가장 큰 “비교적 납작한” 슬라이스 (선초점이 z로 분리될 때)
+	        if (!second) {
+	            const flatThreshold = first.ratio * 1.5 + 1e-6;
+	            let best = null;
+	            let bestDepthSpan = -1;
+	            for (const c of allSlices) {
+	                if (c === first || !depthOk(c))
+	                    continue;
+	                if (c.ratio > flatThreshold)
+	                    continue;
+	                const span = Math.abs(c.depth - first.depth);
+	                if (span > bestDepthSpan) {
+	                    bestDepthSpan = span;
+	                    best = c;
+	                }
+	            }
+	            if (best)
+	                second = best;
+	        }
+	        return second ? [first, second] : [first];
 	    }
-	    isOpticallyNeutral() {
-	        return (Math.abs(Number(this.s) || 0) < STSurface.POWER_EPS_D
-	            && Math.abs(Number(this.c) || 0) < STSurface.POWER_EPS_D);
+	    buildApproxCenter(flattestTop2, smallestEllipse, preferTop2Mid) {
+	        if (flattestTop2.length <= 0)
+	            return null;
+	        if (preferTop2Mid && flattestTop2.length >= 2) {
+	            const first = flattestTop2[0];
+	            const second = flattestTop2[1];
+	            return {
+	                x: (first.profile.at.x + second.profile.at.x) / 2,
+	                y: (first.profile.at.y + second.profile.at.y) / 2,
+	                z: (first.z + second.z) / 2,
+	                mode: "top2-mid",
+	            };
+	        }
+	        if (smallestEllipse) {
+	            return {
+	                x: smallestEllipse.profile.at.x,
+	                y: smallestEllipse.profile.at.y,
+	                z: smallestEllipse.z,
+	                mode: "min-size",
+	            };
+	        }
+	        const first = flattestTop2[0];
+	        return { x: first.profile.at.x, y: first.profile.at.y, z: first.z, mode: "top1-flat" };
 	    }
-	    refract(ray) {
-	        // 무도수 ST면은 기하(면 위치/경사)는 유지하되 굴절력은 0으로 취급하여 직진 통과시킵니다.
-	        if (this.isOpticallyNeutral()) {
-	            const direction = ray.getDirection().normalize();
-	            const passthrough = ray.clone();
-	            const hitPoint = this.sphericalSurface.incident(ray);
-	            if (hitPoint) {
-	                passthrough.appendPoint(hitPoint);
-	                passthrough.continueFrom(hitPoint.clone().addScaledVector(direction, RAY_SURFACE_ESCAPE_MM), direction);
+	    slicesForSturmAnalysis(sturmSlices, bounds) {
+	        if (!bounds)
+	            return sturmSlices;
+	        const zMin = bounds.zMin;
+	        const zMax = bounds.zMax;
+	        if (!Number.isFinite(zMin) || !Number.isFinite(zMax) || zMax < zMin)
+	            return sturmSlices;
+	        const bounded = sturmSlices.filter((s) => {
+	            const z = s.profile?.at?.z;
+	            return Number.isFinite(z) && z >= zMin && z <= zMax;
+	        });
+	        return bounded.length >= 2 ? bounded : sturmSlices;
+	    }
+	    groupByFraunhoferLine(rays) {
+	        const groups = new Map();
+	        for (const ray of rays) {
+	            const line = ray.getFraunhoferLine();
+	            const wavelength = ray.getWavelengthNm();
+	            const color = Number(ray.displayColor);
+	            if (!groups.has(line)) {
+	                groups.set(line, {
+	                    line,
+	                    wavelength_nm: wavelength,
+	                    color: Number.isFinite(color) ? color : null,
+	                    rays: [],
+	                });
 	            }
-	            this.refractedRays.push(passthrough.clone());
-	            return passthrough;
-	        }
-	        this.applyChromaticIndicesToSubSurfaces(ray);
-	        // 원통 성분이 없으면 단일(구면)면으로 처리합니다.
-	        if (!this.toricSurface) {
-	            const single = this.sphericalSurface.refract(ray);
-	            if (!single)
-	                return null;
-	            this.refractedRays.push(single.clone());
-	            return single;
+	            const group = groups.get(line);
+	            if (group)
+	                group.rays.push(ray);
 	        }
-	        // +z 진행: 토릭(작은 z) → 구면(큰 z)
-	        const afterToric = this.toricSurface.refract(ray);
-	        if (!afterToric)
-	            return null;
-	        const afterSpherical = this.sphericalSurface.refract(afterToric);
-	        if (!afterSpherical)
-	            return null;
-	        this.refractedRays.push(afterSpherical.clone());
-	        return afterSpherical;
-	    }
-	    incident(ray) {
-	        // 복합면의 첫 hit: +z 기준 토릭이 앞서므로 toricSurface 우선.
-	        const primary = this.toricSurface ?? this.sphericalSurface;
-	        const hitPoint = primary.incident(ray);
-	        if (!hitPoint)
-	            return null;
-	        this.incidentRays.push(ray.clone());
-	        return hitPoint;
+	        return [...groups.values()].sort((a, b) => this.lineOrder.indexOf(a.line) - this.lineOrder.indexOf(b.line));
 	    }
-	    getOptimizedThicknessMm() {
-	        return this.thickness;
+	    analyzeSturmSlices(sturmSlices, effectiveCylinderD, profileWorldZBounds) {
+	        const top2MinGapMm = DEFAULT_STURM_TOP2_MIN_GAP_MM;
+	        const effectiveCylinderThresholdD = DEFAULT_EFFECTIVE_CYLINDER_THRESHOLD_D;
+	        const preferTop2Mid = effectiveCylinderD >= effectiveCylinderThresholdD;
+	        const slicesForAnalysis = this.slicesForSturmAnalysis(sturmSlices, profileWorldZBounds ?? null);
+	        const sortedByFlatness = [...slicesForAnalysis].sort((a, b) => a.ratio - b.ratio);
+	        const flattestTop2 = sortedByFlatness.length > 0
+	            ? this.pickFlattestSturmPair(sortedByFlatness, top2MinGapMm, slicesForAnalysis)
+	            : [];
+	        let smallestEllipse = null;
+	        for (const slice of slicesForAnalysis) {
+	            if (!smallestEllipse || slice.size < smallestEllipse.size)
+	                smallestEllipse = slice;
+	        }
+	        const approxCenter = this.buildApproxCenter(flattestTop2, smallestEllipse, preferTop2Mid);
+	        const anterior = flattestTop2[0] ?? null;
+	        const posterior = preferTop2Mid ? (flattestTop2[1] ?? null) : null;
+	        return {
+	            has_astigmatism: preferTop2Mid,
+	            method: preferTop2Mid ? "sturm-interval-midpoint" : "minimum-ellipse",
+	            anterior,
+	            posterior,
+	            approx_center: approxCenter,
+	        };
 	    }
 	}
-	STSurface.POWER_EPS_D = ST_POWER_EPS_D;
 
-	const TABOToDeg = (TABOAngle) => {
-	    const t = Number(TABOAngle);
-	    if (!Number.isFinite(t))
-	        return 0;
-	    return (((180 - t) % 180) + 180) % 180;
+	const DEFAULT_LIGHT_SOURCE_CONFIG = {
+	    type: "grid",
+	    width: 10,
+	    height: 10,
+	    division: 4,
+	    z: -10,
+	    vergence: 0,
 	};
-
+	// ================ Helper functions ================
+	function toFiniteNumber(value, fallback = 0) {
+	    const parsed = Number(value);
+	    return Number.isFinite(parsed) ? parsed : fallback;
+	}
+	function normalizePrismAmount(value) {
+	    const p = Number(value ?? 0);
+	    return Number.isFinite(p) ? Math.max(0, p) : 0;
+	}
+	function normalizeAngle360(value) {
+	    const d = Number(value ?? 0);
+	    if (!Number.isFinite(d))
+	        return 0;
+	    return ((d % 360) + 360) % 360;
+	}
+	function normalizeEyeTilt(value) {
+	    return {
+	        x: toFiniteNumber(value?.x),
+	        y: toFiniteNumber(value?.y),
+	    };
+	}
+	function normalizeLightSourcePose(value) {
+	    return {
+	        position: {
+	            x: toFiniteNumber(value?.position?.x),
+	            y: toFiniteNumber(value?.position?.y),
+	            z: toFiniteNumber(value?.position?.z),
+	        },
+	        tilt: {
+	            x: toFiniteNumber(value?.tilt?.x),
+	            y: toFiniteNumber(value?.tilt?.y),
+	        },
+	    };
+	}
+	function isNormalizedEngineConfig(config) {
+	    const candidate = config;
+	    return (candidate.eyeModel !== undefined
+	        && candidate.eye !== undefined
+	        && candidate.light_source !== undefined
+	        && candidate.pupil_type !== undefined
+	        && Array.isArray(candidate.lens));
+	}
+	function normalizeEngineProps(props = {}) {
+	    const eyeModel = props.eyeModel ?? "gullstrand";
+	    const eyeInput = props.eye ?? { s: 0, c: 0, ax: 0, p: 0, p_ax: 0 };
+	    const lensInput = Array.isArray(props.lens) ? props.lens : [];
+	    const lightSourceInput = props.light_source ?? DEFAULT_LIGHT_SOURCE_CONFIG;
+	    const normalizedLightSourcePose = normalizeLightSourcePose(lightSourceInput);
+	    return {
+	        eyeModel,
+	        eye: {
+	            s: toFiniteNumber(eyeInput?.s),
+	            c: toFiniteNumber(eyeInput?.c),
+	            ax: toFiniteNumber(eyeInput?.ax),
+	            p: normalizePrismAmount(eyeInput?.p),
+	            p_ax: normalizeAngle360(eyeInput?.p_ax),
+	            tilt: normalizeEyeTilt(eyeInput?.tilt),
+	        },
+	        lens: lensInput.map((spec) => ({
+	            s: toFiniteNumber(spec?.s),
+	            c: toFiniteNumber(spec?.c),
+	            ax: toFiniteNumber(spec?.ax),
+	            p: normalizePrismAmount(spec?.p),
+	            p_ax: normalizeAngle360(spec?.p_ax),
+	            position: {
+	                x: toFiniteNumber(spec?.position?.x),
+	                y: toFiniteNumber(spec?.position?.y),
+	                z: toFiniteNumber(spec?.position?.z, SPECTACLE_VERTEX_DISTANCE_MM),
+	            },
+	            tilt: {
+	                x: toFiniteNumber(spec?.tilt?.x),
+	                y: toFiniteNumber(spec?.tilt?.y),
+	            },
+	        })),
+	        light_source: {
+	            ...lightSourceInput,
+	            position: { ...normalizedLightSourcePose.position },
+	            tilt: { ...normalizedLightSourcePose.tilt },
+	        },
+	        pupil_type: props.pupil_type ?? "neutral",
+	    };
+	}
 	/**
 	 * legacy simulator.js를 TypeScript로 옮긴 핵심 시뮬레이터입니다.
 	 * - 광원 광선을 생성하고
@@ -8939,7 +9296,10 @@
 	 * - Sturm 분석까지 제공합니다.
 	 */
 	class SCAXEngineCore {
-	    constructor(props = {}) {
+	    get eyeModelParameter() {
+	        return this._eyeModelParameter;
+	    }
+	    constructor(config = {}) {
 	        this.tracedRays = [];
 	        this.lastSourceRaysForSturm = [];
 	        this.lastSturmGapAnalysis = null;
@@ -8948,14 +9308,14 @@
 	        this.sortedEyeSurfaces = [];
 	        this.sturm = new Sturm();
 	        this.affine = new Affine();
-	        this.configure(props);
+	        this.configure(isNormalizedEngineConfig(config) ? config : normalizeEngineProps(config));
 	    }
 	    /**
 	     * 생성자와 동일한 기본값 규칙으로 광학 설정을 다시 적용합니다.
 	     * 생략한 최상위 필드는 매번 기본값으로 돌아갑니다(이전 값과 병합하지 않음).
 	     */
-	    update(props = {}) {
-	        this.configure(props);
+	    update(config = {}) {
+	        this.configure(isNormalizedEngineConfig(config) ? config : normalizeEngineProps(config));
 	    }
 	    dispose() {
 	        [...this.lens, ...this.surfaces].forEach((surface) => {
@@ -8970,141 +9330,40 @@
 	        this.sortedEyeSurfaces = [];
 	        this.sortedLensSurfaces = [];
 	    }
-	    configure(props = {}) {
+	    configure(config) {
 	        this.lastSturmGapAnalysis = null;
 	        this.lastAffineAnalysis = null;
-	        const { eyeModel = "gullstrand", eye = { s: 0, c: 0, ax: 0, p: 0, p_ax: 0 }, lens = [], light_source = { type: "grid", width: 10, height: 10, division: 4, z: -10, vergence: 0 }, pupil_type = "neutral", } = props;
-	        this.eyeModel = eyeModel;
-	        const normalizedEyeSphere = this.toFiniteNumber(eye?.s) + (eyeModel === "gullstrand" ? -1 : 0);
-	        // eye 입력은 auto refractor(굴절오차) 기준이므로,
-	        // 광학면에 적용할 때는 보정렌즈 파워 관점으로 부호를 반전합니다.
-	        this.eyePower = {
-	            s: -normalizedEyeSphere,
-	            c: -this.toFiniteNumber(eye?.c),
-	            ax: this.toFiniteNumber(eye?.ax),
-	        };
-	        this.eyePrismPrescription = {
-	            p: this.normalizePrismAmount(eye?.p),
-	            p_ax: this.normalizeAngle360(eye?.p_ax),
-	        };
-	        const eyeRx = this.prismVectorFromBase(this.eyePrismPrescription.p, this.eyePrismPrescription.p_ax);
-	        // eye 입력은 "교정 필요량(처방값)"이므로 실제 안구 편위는 역벡터입니다.
-	        this.eyePrismEffectVector = { x: -eyeRx.x, y: -eyeRx.y };
-	        const eyeRotXDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.x);
-	        const eyeRotYDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.y);
-	        this.eyeTiltDeg = this.normalizeEyeTilt(eye?.tilt);
-	        // Apply eye deviation in the opposite direction so a lens with the same
-	        // prism/base prescription can optically compensate the eye deviation.
-	        const eyeEulerXDeg = eyeRotYDeg + this.eyeTiltDeg.x;
-	        const eyeEulerYDeg = (-eyeRotXDeg) + this.eyeTiltDeg.y;
-	        this.eyeRotationQuaternion = new Quaternion().setFromEuler(new Euler((eyeEulerXDeg * Math.PI) / 180, (eyeEulerYDeg * Math.PI) / 180, 0, "XYZ"));
-	        this.eyeRotationQuaternionInverse = this.eyeRotationQuaternion.clone().invert();
-	        this.eyeRotationPivot = new Vector3(0, 0, SCAXEngineCore.EYE_ROTATION_PIVOT_FROM_CORNEA_MM);
-	        const normalizedLightSourcePose = this.normalizeLightSourcePose(light_source);
-	        this.lightSourcePosition = new Vector3(normalizedLightSourcePose.position.x, normalizedLightSourcePose.position.y, normalizedLightSourcePose.position.z);
-	        this.lightSourceTiltDeg = { ...normalizedLightSourcePose.tilt };
-	        this.lightSourceRotationQuaternion = new Quaternion().setFromEuler(new Euler((this.lightSourceTiltDeg.x * Math.PI) / 180, (this.lightSourceTiltDeg.y * Math.PI) / 180, 0, "XYZ"));
-	        // Rotate around the light source local center plane (z), not world origin,
-	        // so tilt changes orientation without unintentionally translating the source center.
-	        this.lightSourceRotationPivot = new Vector3(0, 0, this.toFiniteNumber(light_source?.z));
-	        this.lensConfigs = (Array.isArray(lens) ? lens : []).map((spec) => ({
-	            s: this.toFiniteNumber(spec?.s),
-	            c: this.toFiniteNumber(spec?.c),
-	            ax: this.toFiniteNumber(spec?.ax),
-	            p: this.normalizePrismAmount(spec?.p),
-	            p_ax: this.normalizeAngle360(spec?.p_ax),
+	        const { eyeModel, eye, lens, light_source, pupil_type } = config;
+	        const lensConfigs = lens.map((spec) => ({
+	            s: spec.s,
+	            c: spec.c,
+	            ax: spec.ax,
+	            p: spec.p,
+	            p_ax: spec.p_ax,
 	            position: {
-	                x: this.toFiniteNumber(spec?.position?.x),
-	                y: this.toFiniteNumber(spec?.position?.y),
-	                z: this.toFiniteNumber(spec?.position?.z, SPECTACLE_VERTEX_DISTANCE_MM),
+	                x: spec.position.x,
+	                y: spec.position.y,
+	                z: spec.position.z,
 	            },
 	            tilt: {
-	                x: this.toFiniteNumber(spec?.tilt?.x),
-	                y: this.toFiniteNumber(spec?.tilt?.y),
-	            },
-	            includeInAstigmatismSummary: spec?.includeInAstigmatismSummary !== false,
-	        }));
-	        this.currentProps = {
-	            eyeModel,
-	            eye: {
-	                s: this.toFiniteNumber(eye?.s),
-	                c: this.toFiniteNumber(eye?.c),
-	                ax: this.toFiniteNumber(eye?.ax),
-	                p: this.normalizePrismAmount(eye?.p),
-	                p_ax: this.normalizeAngle360(eye?.p_ax),
-	                tilt: this.normalizeEyeTilt(eye?.tilt),
-	            },
-	            lens: this.lensConfigs.map((spec) => ({
-	                s: this.toFiniteNumber(spec.s),
-	                c: this.toFiniteNumber(spec.c),
-	                ax: this.toFiniteNumber(spec.ax),
-	                p: this.normalizePrismAmount(spec.p),
-	                p_ax: this.normalizeAngle360(spec.p_ax),
-	                position: {
-	                    x: this.toFiniteNumber(spec.position?.x),
-	                    y: this.toFiniteNumber(spec.position?.y),
-	                    z: this.toFiniteNumber(spec.position?.z, SPECTACLE_VERTEX_DISTANCE_MM),
-	                },
-	                tilt: {
-	                    x: this.toFiniteNumber(spec.tilt?.x),
-	                    y: this.toFiniteNumber(spec.tilt?.y),
-	                },
-	                includeInAstigmatismSummary: spec.includeInAstigmatismSummary,
-	            })),
-	            light_source: {
-	                ...light_source,
-	                position: { ...normalizedLightSourcePose.position },
-	                tilt: { ...normalizedLightSourcePose.tilt },
+	                x: spec.tilt.x,
+	                y: spec.tilt.y,
 	            },
-	            pupil_type,
-	        };
-	        this.lensPowers = this.lensConfigs.map((spec) => ({
-	            s: this.toFiniteNumber(spec?.s),
-	            c: this.toFiniteNumber(spec?.c),
-	            ax: this.toFiniteNumber(spec?.ax),
 	        }));
-	        // eye/lens prism axis는 모두 임상 Base 방향(렌즈->각막 시점)으로 입력합니다.
-	        // 내부 광선 편향 벡터는 Base의 반대방향(= +180° 변환)으로 계산합니다.
-	        this.lensPrismVector = this.lensConfigs.reduce((acc, spec) => {
-	            const v = this.prismVectorFromBase(spec.p ?? 0, spec.p_ax ?? 0);
-	            return { x: acc.x + v.x, y: acc.y + v.y };
-	        }, { x: 0, y: 0 });
 	        // "none"은 동공 제한을 완전히 비활성화합니다.
-	        this.pupilDiameterMm = pupil_type === "none" ? 0 : Number(PUPIL_SIZE[pupil_type]);
-	        this.eyeModelParameter = eyeModel === "gullstrand" ? new GullstrandParameter() : new NavarroParameter();
-	        const eyeSt = new STSurface({
-	            type: "compound",
-	            name: "eye_st",
-	            position: { x: 0, y: 0, z: -EYE_ST_SURFACE_OFFSET_MM },
-	            referencePoint: { x: 0, y: 0, z: 0 },
-	            tilt: { x: 0, y: 0 },
-	            s: this.eyePower.s,
-	            c: this.eyePower.c,
-	            ax: this.eyePower.ax,
-	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
-	            n: FRAUNHOFER_REFRACTIVE_INDICES.cornea,
-	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.aqueous,
+	        const pupilMm = pupil_type === "none" ? 0 : Number(PUPIL_SIZE[pupil_type]);
+	        this._eyeModelParameter = eyeModel === "gullstrand" ? new GullstrandParameter() : new NavarroParameter();
+	        this.surfaces = this._eyeModelParameter.createSurface({
+	            eyeModel,
+	            s: eye.s,
+	            c: eye.c,
+	            ax: eye.ax,
+	            p: eye.p,
+	            p_ax: eye.p_ax,
+	            tilt: eye.tilt,
+	            pupilDiameterMm: pupilMm,
 	        });
-	        this.surfaces = [eyeSt, ...this.eyeModelParameter.createSurface()];
-	        this.hasPupilStop = false;
-	        if (Number.isFinite(this.pupilDiameterMm) && this.pupilDiameterMm > 0) {
-	            const pupilStop = new ApertureStopSurface({
-	                type: "aperture_stop",
-	                name: "pupil_stop",
-	                shape: "circle",
-	                radius: this.pupilDiameterMm / 2,
-	                // eye_st(눈 굴절력 surface)의 첫 굴절면(back vertex) 바로 앞에서 차단/통과를 판정합니다.
-	                position: {
-	                    x: 0,
-	                    y: 0,
-	                    z: -EYE_ST_SURFACE_OFFSET_MM - (2 * RAY_SURFACE_ESCAPE_MM),
-	                },
-	                tilt: { x: 0, y: 0 },
-	            });
-	            this.surfaces = [pupilStop, ...this.surfaces];
-	            this.hasPupilStop = true;
-	        }
-	        this.lens = this.lensConfigs.map((spec, index) => new STSurface({
+	        this.lens = lensConfigs.map((spec, index) => new STSurface({
 	            type: "compound",
 	            name: `lens_st_${index + 1}`,
 	            position: {
@@ -9117,12 +9376,14 @@
 	            // 1) back surface is fixed at vertex distance(position.z)
 	            // 2) back-front gap is optimized (thickness=0 => auto)
 	            thickness: 0,
-	            s: this.toFiniteNumber(spec?.s),
-	            c: this.toFiniteNumber(spec?.c),
-	            ax: this.toFiniteNumber(spec?.ax),
+	            s: spec.s,
+	            c: spec.c,
+	            ax: spec.ax,
 	            n_before: FRAUNHOFER_REFRACTIVE_INDICES.air,
 	            n: FRAUNHOFER_REFRACTIVE_INDICES.crown_glass,
 	            n_after: FRAUNHOFER_REFRACTIVE_INDICES.air,
+	            p: spec.p,
+	            p_ax: spec.p_ax,
 	        }));
 	        this.light_source = light_source.type === "radial"
 	            ? new RadialLightSource(light_source)
@@ -9138,52 +9399,7 @@
 	    simulate() {
 	        const tracedRays = this.rayTracing();
 	        this.sturmCalculation(tracedRays);
-	        const lightDeviation = this.calculateLightDeviation();
-	        return {
-	            traced_rays: tracedRays,
-	            info: {
-	                astigmatism: {
-	                    eye: this.principalMeridiansFromPowers([this.eyePower]),
-	                    lens: this.principalMeridiansFromPowers(this.astigmatismSummaryLensPowers()),
-	                    combined: this.principalMeridiansFromPowers([
-	                        this.eyePower,
-	                        ...this.lensPowers,
-	                    ]),
-	                },
-	                prism: {
-	                    eye: this.toPrismSummaryItem(lightDeviation.eye_prism_effect),
-	                    lens: this.toPrismSummaryItem(lightDeviation.lens_prism_total),
-	                    combined: this.toPrismSummaryItem(lightDeviation.net_prism),
-	                },
-	            },
-	        };
-	    }
-	    /**
-	     * eye.p / eye.p_ax(처방값)를 기준으로, 렌더링에서 바로 쓸 눈 회전량을 반환합니다.
-	     * - x_deg/y_deg는 프리즘 회전량에 eye.tilt를 합산한 최종 렌더 회전량입니다.
-	     */
-	    getEyeRotation() {
-	        // Keep render rotation strictly aligned with the internal eye rotation used in ray tracing.
-	        // Internal eye-space Euler:
-	        //   eyeEulerXDeg = eyeRotYDeg + tilt.x
-	        //   eyeEulerYDeg = (-eyeRotXDeg) + tilt.y
-	        // UI mapping (applyEyeRenderRotation):
-	        //   object.rotation.x = -y_deg
-	        //   object.rotation.y =  x_deg
-	        // so we expose:
-	        //   x_deg = eyeEulerYDeg
-	        //   y_deg = -eyeEulerXDeg
-	        const eyeRotXDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.x);
-	        const eyeRotYDeg = this.prismComponentToAngleDeg(this.eyePrismEffectVector.y);
-	        const eyeEulerXDeg = eyeRotYDeg + this.eyeTiltDeg.x;
-	        const eyeEulerYDeg = (-eyeRotXDeg) + this.eyeTiltDeg.y;
-	        const xDeg = eyeEulerYDeg;
-	        const yDeg = -eyeEulerXDeg;
-	        return {
-	            x_deg: xDeg,
-	            y_deg: yDeg,
-	            magnitude_deg: Math.hypot(xDeg, yDeg),
-	        };
+	        return { traced_rays: tracedRays };
 	    }
 	    /**
 	     * 1) Ray tracing 전용 함수
@@ -9194,10 +9410,8 @@
 	        const eyeSurfaces = this.sortedEyeSurfaces;
 	        lensSurfaces.forEach((surface) => surface.clearTraceHistory());
 	        eyeSurfaces.forEach((surface) => surface.clearTraceHistory());
-	        const emittedSourceRays = this.light_source.emitRays().map((ray) => this.applyLightSourceTransformToRay(ray));
-	        const sourceRays = this.hasPupilStop
-	            ? emittedSourceRays
-	            : emittedSourceRays.filter((ray) => this.isRayInsidePupil(ray));
+	        const emittedSourceRays = this.light_source.emitRays();
+	        const sourceRays = emittedSourceRays;
 	        this.lastSourceRaysForSturm = sourceRays.map((ray) => ray.clone());
 	        const traced = [];
 	        for (const sourceRay of sourceRays) {
@@ -9216,8 +9430,6 @@
 	                    traced.push(activeRay);
 	                continue;
 	            }
-	            activeRay = this.applyPrismVectorToRay(activeRay, this.lensPrismVector);
-	            activeRay = this.transformRayAroundPivot(activeRay, this.eyeRotationQuaternionInverse, this.eyeRotationPivot);
 	            for (const surface of eyeSurfaces) {
 	                const nextRay = surface.refract(activeRay);
 	                if (!(nextRay instanceof Ray)) {
@@ -9226,7 +9438,6 @@
 	                }
 	                activeRay = nextRay;
 	            }
-	            activeRay = this.transformRayAroundPivot(activeRay, this.eyeRotationQuaternion, this.eyeRotationPivot);
 	            if (valid) {
 	                traced.push(activeRay);
 	            }
@@ -9298,17 +9509,6 @@
 	        const points = ray.points;
 	        return Array.isArray(points) ? points : [];
 	    }
-	    isRayInsidePupil(ray) {
-	        const diameter = this.pupilDiameterMm;
-	        if (!Number.isFinite(diameter) || diameter <= 0)
-	            return true;
-	        const radius = diameter / 2;
-	        const points = this.getRayPoints(ray);
-	        const origin = points[0];
-	        if (!origin)
-	            return false;
-	        return Math.hypot(origin.x, origin.y) <= radius + 1e-6;
-	    }
 	    powerVectorFromCylinder(cylinderD, axisDeg) {
 	        const c = Number(cylinderD);
 	        const ax = ((Number(axisDeg) % 180) + 180) % 180;
@@ -9318,221 +9518,10 @@
 	        const scale = -c / 2;
 	        return { j0: scale * Math.cos(rad), j45: scale * Math.sin(rad) };
 	    }
-	    aggregatePowerVector(powers) {
-	        let m = 0;
-	        let j0 = 0;
-	        let j45 = 0;
-	        for (const power of powers) {
-	            const sphere = Number(power?.s ?? 0);
-	            const cylinder = Number(power?.c ?? 0);
-	            const axisTABO = Number(power?.ax ?? 0);
-	            if (!Number.isFinite(sphere) || !Number.isFinite(cylinder) || !Number.isFinite(axisTABO))
-	                continue;
-	            const axisDeg = DegToTABO(axisTABO);
-	            const rad = (2 * axisDeg * Math.PI) / 180;
-	            const halfMinusCylinder = -cylinder / 2;
-	            m += sphere + (cylinder / 2);
-	            j0 += halfMinusCylinder * Math.cos(rad);
-	            j45 += halfMinusCylinder * Math.sin(rad);
-	        }
-	        return { m, j0, j45 };
-	    }
-	    /** 난시 주경선 TABO 각도: 180° 동치이므로 표시·비교는 항상 [0, 180)으로 맞춘다. */
-	    normalizeTaboMeridian180(value) {
-	        const d = Number(value ?? 0);
-	        if (!Number.isFinite(d))
-	            return 0;
-	        return ((d % 180) + 180) % 180;
-	    }
-	    principalMeridiansFromVector(m, j0, j45) {
-	        if (!Number.isFinite(m) || !Number.isFinite(j0) || !Number.isFinite(j45))
-	            return [];
-	        const axisDeg = (((0.5 * Math.atan2(j45, j0) * 180) / Math.PI) % 180 + 180) % 180;
-	        const taboAxis = this.normalizeTaboMeridian180(TABOToDeg(axisDeg));
-	        const orthogonalTabo = (taboAxis + 90) % 180;
-	        const r = Math.hypot(j0, j45);
-	        const meridians = [
-	            { tabo: taboAxis, d: m - r },
-	            { tabo: orthogonalTabo, d: m + r },
-	        ];
-	        return meridians.sort((a, b) => a.d - b.d);
-	    }
-	    astigmatismSummaryLensPowers() {
-	        return this.lensConfigs
-	            .filter((spec) => spec.includeInAstigmatismSummary)
-	            .map((spec) => ({
-	            s: this.toFiniteNumber(spec.s),
-	            c: this.toFiniteNumber(spec.c),
-	            ax: this.toFiniteNumber(spec.ax),
-	        }));
-	    }
-	    principalMeridiansFromPowers(powers) {
-	        if (powers.length === 0)
-	            return [];
-	        const { m, j0, j45 } = this.aggregatePowerVector(powers);
-	        return this.principalMeridiansFromVector(m, j0, j45);
-	    }
-	    normalizePrismAmount(value) {
-	        const p = Number(value ?? 0);
-	        return Number.isFinite(p) ? Math.max(0, p) : 0;
-	    }
-	    normalizeAngle360(value) {
-	        const d = Number(value ?? 0);
-	        if (!Number.isFinite(d))
-	            return 0;
-	        return ((d % 360) + 360) % 360;
-	    }
-	    normalizeEyeTilt(value) {
-	        return {
-	            x: this.toFiniteNumber(value?.x),
-	            y: this.toFiniteNumber(value?.y),
-	        };
-	    }
-	    normalizeLightSourcePose(value) {
-	        return {
-	            position: {
-	                x: this.toFiniteNumber(value?.position?.x),
-	                y: this.toFiniteNumber(value?.position?.y),
-	                z: this.toFiniteNumber(value?.position?.z),
-	            },
-	            tilt: {
-	                x: this.toFiniteNumber(value?.tilt?.x),
-	                y: this.toFiniteNumber(value?.tilt?.y),
-	            },
-	        };
-	    }
-	    toFiniteNumber(value, fallback = 0) {
-	        const parsed = Number(value);
-	        return Number.isFinite(parsed) ? parsed : fallback;
-	    }
 	    refreshSortedSurfaces() {
 	        this.sortedLensSurfaces = [...this.lens].sort((a, b) => this.surfaceOrderZ(a) - this.surfaceOrderZ(b));
 	        this.sortedEyeSurfaces = [...this.surfaces].sort((a, b) => this.surfaceOrderZ(a) - this.surfaceOrderZ(b));
 	    }
-	    prismVectorFromBase(prismDiopter, baseAngleDeg) {
-	        const p = this.normalizePrismAmount(prismDiopter);
-	        const baseAngle = this.normalizeAngle360(baseAngleDeg);
-	        // Clinical Base convention:
-	        // - input axis is prism base direction, viewed from lens side toward cornea (OD: right=0°)
-	        // - light deviation is opposite to base, so internally convert by +180°
-	        const deviationAngle = this.normalizeAngle360(baseAngle + 180);
-	        // Internal x/y uses math-style +x right, +y up.
-	        // Because user axis is defined from lens->cornea view, flip angular direction by negating theta.
-	        const rad = (-deviationAngle * Math.PI) / 180;
-	        return {
-	            x: p * Math.cos(rad),
-	            y: p * Math.sin(rad),
-	        };
-	    }
-	    vectorToPrismInfo(x, y) {
-	        const xx = Number.isFinite(x) ? x : 0;
-	        const yy = Number.isFinite(y) ? y : 0;
-	        const magnitude = Math.hypot(xx, yy);
-	        const angleDeg = this.normalizeAngle360((Math.atan2(yy, xx) * 180) / Math.PI);
-	        return {
-	            x: xx,
-	            y: yy,
-	            magnitude,
-	            angle_deg: magnitude < 1e-12 ? 0 : angleDeg,
-	        };
-	    }
-	    toPrismSummaryItem(value) {
-	        const magnitude = Number(value?.magnitude);
-	        return {
-	            p_x: Number(value?.x ?? 0),
-	            p_y: Number(value?.y ?? 0),
-	            prism_angle: this.normalizeAngle360(value?.angle_deg),
-	            magnitude: Number.isFinite(magnitude) && magnitude >= 1e-9 ? magnitude : null,
-	        };
-	    }
-	    prismComponentToAngleDeg(componentPrism) {
-	        const c = Number(componentPrism);
-	        if (!Number.isFinite(c))
-	            return 0;
-	        return (Math.atan(c / 100) * 180) / Math.PI;
-	    }
-	    prismMagnitudeToAngleDeg(prismDiopter) {
-	        const p = Number(prismDiopter);
-	        if (!Number.isFinite(p) || p < 1e-12)
-	            return 0;
-	        return (Math.atan(p / 100) * 180) / Math.PI;
-	    }
-	    applyPrismVectorToRay(ray, prism) {
-	        const px = Number(prism?.x ?? 0);
-	        const py = Number(prism?.y ?? 0);
-	        if (!Number.isFinite(px)
-	            || !Number.isFinite(py)
-	            || (Math.abs(px) < 1e-12 && Math.abs(py) < 1e-12)) {
-	            return ray;
-	        }
-	        const direction = ray.getDirection();
-	        const dz = Number(direction.z);
-	        if (!Number.isFinite(dz) || Math.abs(dz) < 1e-12)
-	            return ray;
-	        const tx = (direction.x / dz) + (px / 100);
-	        const ty = (direction.y / dz) + (py / 100);
-	        const signZ = dz >= 0 ? 1 : -1;
-	        const newDirection = new Vector3(tx * signZ, ty * signZ, signZ).normalize();
-	        if (!Number.isFinite(newDirection.x) || !Number.isFinite(newDirection.y) || !Number.isFinite(newDirection.z)) {
-	            return ray;
-	        }
-	        const updated = ray.clone();
-	        const origin = updated.endPoint();
-	        updated.continueFrom(origin.clone().addScaledVector(newDirection, RAY_SURFACE_ESCAPE_MM), newDirection);
-	        return updated;
-	    }
-	    rotatePointAroundPivot(point, rotation, pivot) {
-	        return point.clone().sub(pivot).applyQuaternion(rotation).add(pivot);
-	    }
-	    translateRay(ray, offset) {
-	        if (offset.lengthSq() < 1e-12)
-	            return ray;
-	        const points = this.getRayPoints(ray);
-	        if (!points.length)
-	            return ray;
-	        const translated = ray.clone();
-	        const translatedState = translated;
-	        const nextPoints = points.map((point) => point.clone().add(offset));
-	        translatedState.points = nextPoints;
-	        translatedState.origin = nextPoints[nextPoints.length - 1].clone();
-	        return translated;
-	    }
-	    transformRayAroundPivot(ray, rotation, pivot) {
-	        const points = this.getRayPoints(ray);
-	        if (!points.length)
-	            return ray;
-	        const transformed = ray.clone();
-	        const transformedState = transformed;
-	        const nextPoints = points.map((point) => this.rotatePointAroundPivot(point, rotation, pivot));
-	        transformedState.points = nextPoints;
-	        transformedState.direction = ray.getDirection().clone().applyQuaternion(rotation).normalize();
-	        transformedState.origin = nextPoints[nextPoints.length - 1].clone();
-	        return transformed;
-	    }
-	    applyLightSourceTransformToRay(ray) {
-	        const rotated = this.transformRayAroundPivot(ray, this.lightSourceRotationQuaternion, this.lightSourceRotationPivot);
-	        return this.translateRay(rotated, this.lightSourcePosition);
-	    }
-	    calculateLightDeviation() {
-	        // eye/lens 입력은 모두 임상 Base 방향이므로, prismVectorFromBase 내부에서
-	        // Base -> 광선편향(+180°) 변환이 적용됩니다.
-	        // eye는 "처방값(교정 필요량)"으로 해석하므로 실제 눈 편위는 역벡터입니다.
-	        const eyeEffect = this.vectorToPrismInfo(this.eyePrismEffectVector.x, this.eyePrismEffectVector.y);
-	        // lens 입력은 교정량이며, 렌즈는 Base 반대방향으로 광선을 실제 굴절시킵니다.
-	        // prismVectorFromBase에서 Base->광선편향이 이미 반영된 벡터를 그대로 합산합니다.
-	        const lensX = this.lensPrismVector.x;
-	        const lensY = this.lensPrismVector.y;
-	        const lensTotal = this.vectorToPrismInfo(lensX, lensY);
-	        const net = this.vectorToPrismInfo(eyeEffect.x + lensTotal.x, eyeEffect.y + lensTotal.y);
-	        return {
-	            eye_prism_effect: eyeEffect,
-	            lens_prism_total: lensTotal,
-	            net_prism: net,
-	            x_angle_deg: this.prismComponentToAngleDeg(net.x),
-	            y_angle_deg: this.prismComponentToAngleDeg(net.y),
-	            net_angle_deg: this.prismMagnitudeToAngleDeg(net.magnitude),
-	        };
-	    }
 	    effectiveCylinderFromOpticSurfaces() {
 	        let j0 = 0;
 	        let j45 = 0;
@@ -9578,14 +9567,14 @@
 	            .filter((pair) => Boolean(pair));
 	    }
 	}
-	SCAXEngineCore.EYE_ROTATION_PIVOT_FROM_CORNEA_MM = 13;
 	/**
 	 * 외부 공개 API 전용 Facade입니다.
 	 * 내부 광학 상태/연산은 SCAXEngineCore에 위임합니다.
 	 */
 	class SCAXEngine {
 	    constructor(props = {}) {
-	        this.core = new SCAXEngineCore(props);
+	        this.normalizedConfig = normalizeEngineProps(props);
+	        this.core = new SCAXEngineCore(this.normalizedConfig);
 	    }
 	    // Test/debug bridge for legacy direct field access patterns.
 	    get lens() {
@@ -9598,7 +9587,8 @@
 	        return this.core.surfaces;
 	    }
 	    update(props = {}) {
-	        this.core.update(props);
+	        this.normalizedConfig = normalizeEngineProps(props);
+	        this.core.update(this.normalizedConfig);
 	    }
 	    dispose() {
 	        this.core.dispose();
@@ -9606,17 +9596,52 @@
 	    simulate() {
 	        return this.core.simulate();
 	    }
-	    getEyeRotation() {
-	        return this.core.getEyeRotation();
-	    }
 	    rayTracing() {
 	        return this.core.rayTracing();
 	    }
 	    sturmCalculation(rays) {
 	        return this.core.sturmCalculation(rays);
 	    }
-	    getAffineAnalysis() {
-	        return this.core.getAffineAnalysis();
+	    calculateMeridians(scaxPowers) {
+	        const normalize180 = (angle) => (((angle % 180) + 180) % 180);
+	        const taboToDeg = (taboAngle) => normalize180(180 - taboAngle);
+	        const degToTabo = (degreeAngle) => normalize180(180 - degreeAngle);
+	        let m = 0;
+	        let j0 = 0;
+	        let j45 = 0;
+	        for (const power of Array.isArray(scaxPowers) ? scaxPowers : []) {
+	            const sphere = Number(power?.s ?? 0);
+	            const cylinder = Number(power?.c ?? 0);
+	            const axisTABO = Number(power?.ax ?? 0);
+	            if (!Number.isFinite(sphere) || !Number.isFinite(cylinder) || !Number.isFinite(axisTABO))
+	                continue;
+	            const axisDeg = taboToDeg(axisTABO);
+	            const rad = (2 * axisDeg * Math.PI) / 180;
+	            const halfMinusCylinder = -cylinder / 2;
+	            m += sphere + (cylinder / 2);
+	            j0 += halfMinusCylinder * Math.cos(rad);
+	            j45 += halfMinusCylinder * Math.sin(rad);
+	        }
+	        if (!Number.isFinite(m) || !Number.isFinite(j0) || !Number.isFinite(j45))
+	            return [];
+	        const axisDeg = normalize180((0.5 * Math.atan2(j45, j0) * 180) / Math.PI);
+	        const taboAxis = degToTabo(axisDeg);
+	        const orthogonalTabo = (taboAxis + 90) % 180;
+	        const r = Math.hypot(j0, j45);
+	        return [
+	            { tabo: taboAxis, d: m - r },
+	            { tabo: orthogonalTabo, d: m + r },
+	        ].sort((a, b) => a.d - b.d);
+	    }
+	    calculateEyeRotationByPrism(prism) {
+	        // 프리즘 처방으로 인한 안구 회전량만 계산 (tilt 제외)
+	        const p = normalizePrismAmount(prism?.p);
+	        const p_ax = normalizeAngle360(prism?.p_ax);
+	        const rotation = eyeRotationForRenderDegrees(p, p_ax, { x: 0, y: 0 });
+	        return {
+	            x: Number.isFinite(rotation.x_deg) ? rotation.x_deg : 0,
+	            y: Number.isFinite(rotation.y_deg) ? rotation.y_deg : 0,
+	        };
 	    }
 	}