scax-engine 0.1.7 → 0.2.0-beta.1

package/dist/scax-engine.cjs

@@ -6737,119 +6737,6 @@ const _m = /*@__PURE__*/ new Matrix3();
 
 _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],
-        };
-    }
-}
-
 /**
  * 프라운호퍼 파장과 색상
  */
@@ -7126,9 +7013,125 @@ class Ray {
     }
 }
 
+/**
+ * 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) {
@@ -7163,13 +7166,62 @@ class LightSource {
     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");
         }
@@ -7190,6 +7242,7 @@ class GridLightSource extends LightSource {
         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;
@@ -7206,7 +7259,7 @@ class GridLightSource extends LightSource {
 }
 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");
         }
@@ -7227,6 +7280,7 @@ class GridRGLightSource extends LightSource {
         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;
@@ -7244,7 +7298,7 @@ class GridRGLightSource extends LightSource {
 }
 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");
         }
@@ -7268,6 +7322,7 @@ class RadialLightSource extends LightSource {
         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;
@@ -7282,26 +7337,76 @@ class RadialLightSource extends LightSource {
     }
 }
 
-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 {
@@ -7323,6 +7428,118 @@ class Surface {
         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 {
@@ -7851,1083 +8068,1223 @@ class SphericalSurface extends Surface {
     }
 }
 
-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로 옮긴 핵심 시뮬레이터입니다.
  * - 광원 광선을 생성하고
@@ -8935,7 +9292,10 @@ const TABOToDeg = (TABOAngle) => {
  * - Sturm 분석까지 제공합니다.
  */
 class SCAXEngineCore {
-    constructor(props = {}) {
+    get eyeModelParameter() {
+        return this._eyeModelParameter;
+    }
+    constructor(config = {}) {
         this.tracedRays = [];
         this.lastSourceRaysForSturm = [];
         this.lastSturmGapAnalysis = null;
@@ -8944,14 +9304,14 @@ class SCAXEngineCore {
         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) => {
@@ -8966,141 +9326,40 @@ class SCAXEngineCore {
         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: {
@@ -9113,12 +9372,14 @@ class SCAXEngineCore {
             // 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)
@@ -9134,52 +9395,7 @@ class SCAXEngineCore {
     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.astigmatismSummaryLensPowers(),
-                    ]),
-                },
-                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 전용 함수
@@ -9190,10 +9406,8 @@ class SCAXEngineCore {
         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) {
@@ -9212,8 +9426,6 @@ class SCAXEngineCore {
                     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)) {
@@ -9222,7 +9434,6 @@ class SCAXEngineCore {
                 }
                 activeRay = nextRay;
             }
-            activeRay = this.transformRayAroundPivot(activeRay, this.eyeRotationQuaternion, this.eyeRotationPivot);
             if (valid) {
                 traced.push(activeRay);
             }
@@ -9294,17 +9505,6 @@ class SCAXEngineCore {
         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;
@@ -9314,221 +9514,10 @@ class SCAXEngineCore {
         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;
@@ -9574,14 +9563,14 @@ class SCAXEngineCore {
             .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() {
@@ -9594,7 +9583,8 @@ class SCAXEngine {
         return this.core.surfaces;
     }
     update(props = {}) {
-        this.core.update(props);
+        this.normalizedConfig = normalizeEngineProps(props);
+        this.core.update(this.normalizedConfig);
     }
     dispose() {
         this.core.dispose();
@@ -9602,17 +9592,52 @@ class SCAXEngine {
     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,
+        };
     }
 }