Aislo/B06_Section/B06_Section_Cross_Refresh.ts

/* =============================================================================
 * B06_Section_Cross_Refresh.ts
 * 「현재 계획선에 맞춘 횡단 재계산」 **단일 창구** — B05·B06이 같은 입력으로 같은 결과를 본다.
 *
 * ── 계산은 브라우저 안에서 끝난다 (2026-09-03 사용자 확정) ───────────
 * 사용자 조작 중의 계산은 서버로 나가지 않는다. 조작은 세션 캐시에 쌓이고 화면은 즉시
 * 따라오며, 영구저장소는 [저장]·[확정]에서만 건드린다. 예전에는 계획고가 바뀔 때마다
 * `POST …/cross-design/preview` 로 전 측점 횡단을 서버에 물어, 왕복이 조작 속도를
 * 지배했다(2026-09-03 사용자 보고: 「종단을 바꾸면 업데이트가 느리다」).
 *
 * 그래서 설계 계산은 `common_util_cross_design.ts`(파이썬 `B06_Section_Engine_Design.py`
 * 의 미러)로 옮겼고, 여기서는 **입력을 모아 전 측점을 돌리고 제자리 반영**만 한다.
 * 서버 프리뷰는 선형 저장분이 없어 계획고를 못 푸는 **옛 데이터 폴백**으로만 남는다.
 *
 * ⚠ 두 벌 계산 주의 — TS 미러(`common_util_cross_design*.ts`)와 파이썬 엔진
 *   (`B06_Section_Engine_Design.py`·`B06_Section_Engine_Areas.py`)은 한 벌이다.
 *   한쪽만 고치면 화면과 저장본이 갈린다. 회귀 테스트:
 *   `tmp/tests/test_b06_cross_design_mirror.py`
 *
 * ── 왜 창구가 하나여야 하는가 (2026-09-03 실측) ──────────────────────
 * 재계산 호출이 두 벌이던 시절, 같은 프로젝트·같은 시점에 B06 `절토(자연) 3,704.6㎥`
 * ↔ B05 `4,526.8㎥` 로 갈렸다. 원인은 인자였다 — 표준 단면값과 암 경계 오프셋이 빠지면
 * 서버가 다른 설계를 그린다. 입력 수집·계산·제자리 반영을 여기 한 곳에 모아 둔다. 세션
 * 편집값은 패널이 아니라 세션 저장소에서 직접 읽으므로, 패널이 없는 B05도 같은 값을 쓴다.
 * ========================================================================== */

import { computeCrossDesign } from "@util/common_util_cross_design";
import type { CrossDesignOptions, StandardCrossSectionSpec } from "@util/common_util_cross_design";
import { previewCrossDesigns } from "./B06_Section_Api_Fetch";
import type { CrossSection, SectionDetailResponse } from "./B06_Section_Api_Fetch";
import {
  bermSpecAt,
  readBermSpans,
  readCutSlopeSession,
  readRockBoundarySession,
} from "./B06_Section_UI_Page_Persist";
import type { BermSessionSpec } from "./B06_Section_UI_Page_Persist";
import type { BermSpec } from "@util/common_util_cross_berm";
import {
  crossDesignChoices,
  readBermDepths,
  readShoulderExtends,
} from "./B06_Section_Cross_Design_Session";
import {
  effectiveStandardCross,
  readRockBoundaryDefault,
  readStandardCrossSession,
} from "./B06_Section_UI_Standard_Panel";
import {
  buildAlignment,
  planElevationAt,
  toAlignmentBase,
} from "../B05_Profile/logic/B05_Profile_UI_Profile_Alignment";
import type { ProfileAlignment } from "../B05_Profile/logic/B05_Profile_UI_Profile_Alignment";
import { readAlignment, toDesignProfile } from "../B05_Profile/logic/B05_Profile_UI_Profile_Data";
import { useStationKeys } from "./B06_Section_Station_Keys";
import { hasStaleDesigns } from "./B06_Section_UI_Section_Common";
import { applyStructureAreaRows, structureAreaRows } from "./B06_Section_Structure_Layouts";

/** 계획선 편집 델타 — B05 `AlignmentEdits`와 저장분 `profile_alignment.edits`가 같은 모양이다. */
export interface CrossRefreshEdits {
  station_offsets: Record<string, number>;
  curve_radii: Record<string, number>;
}

export interface CrossRefreshInput {
  projectId: string;
  routeId: number;
  /** 제자리 갱신 대상 — 공유 캐시가 들고 있는 그 객체여야 두 화면이 같이 따라온다. */
  detail: SectionDetailResponse;
  edits: CrossRefreshEdits;
  /** 화면이 쥔 계획선(측점 한 벌 · 342-1) — 없으면 종단도가 맡긴 선 → 저장분 + `edits`. */
  alignment?: ProfileAlignment | null;
  /**
   * 결과를 **아직 써도 되는지** 묻는다(false면 반영하지 않는다). 로컬 계산은 즉시 끝나
   * 늦은 응답이 없지만, 옛 데이터 폴백(서버 프리뷰)에서는 여전히 문지기가 필요하다.
   */
  shouldApply?: () => boolean;
}

/**
 * 계산이 만들지 않는 **사용자 값** — 다시 계산해도 살려 두고, [저장]·[확정]에도 이 목록으로
 * 실어 보낸다(`B06_Section_Section_Store`). 서버 `B06_Section_Router_Design.USER_TOUCHED_KEYS`
 * 와 **짝**이며 갈리면 시험이 깨진다(`tmp/tests/test_b06_user_touched_keys.py`).
 *
 * 손으로 나열하는 자리를 하나로 모은 것이다(2026-09-07) — 나열이 흩어져 있어 새 값을
 * 더할 때 한 곳만 빠지면 그 값이 조용히 사라졌다(`extra_spans` 실사고 `b6941bd2`).
 */
export const USER_TOUCHED_KEYS = [
  "display_half_width_m",
  "inlet_structure",
  "basin_adjust",
  "revet_adjust",
  "ford_adjust",
  "box_adjust",
  "extra_wall_counts",
  "extra_spans",
  "revet_link_detached",
  "revet_follow_grade",
  // 소단 제원 — 사용자가 구간에 놓은 값이라 다시 계산해도 살려 둔다(계획서 3-9).
  "berm",
  // 측점별 암 절토 경사(2026-09-07) — 표준을 바꿔도 개별로 고친 측점은 그대로 둔다.
  "cut_slope_ratio_user",
  // 측점 구조물 글(138-4 · 횡단 [상세] 모달 맨 위 칸) — 계산 입력이 아님.
  "structure_note",
  // 표 위 CAD 칸(260-1 · [상세] 모달 빈 도면) — 계산 입력이 아님.
  "structure_note_cad",
  // [상세] 표 손질(179-4) — 고른 칸 · 더한 행 · 열(값은 그릴 때 서버가 다시 셈)
  "detail_table",
  // 설계선 쉬프트 = 쪽마다 노견 확장(139-6) — 기하 입력이라 재계산에도 넘김
  "shoulder_extend_left_m",
  "shoulder_extend_right_m",
  // 소단 쪽마다 옮긴 깊이(194-1 · 횡단도 ▲▼) — 기하 입력이라 재계산에도 넘김
  "berm_depth_left_m",
  "berm_depth_right_m",
] as const;

/** 다시 계산해도 살려 두는 값 — 위 사용자 값에 **상태를 나르는 둘**을 더한 것. */
const PRESERVED_KEYS = ["status", "pavement_suggested", ...USER_TOUCHED_KEYS] as const;

/**
 * 포장 = 노면공 · 물넘이 범위 안만(138-1) — 측점에 얹힌 제원(`pavement` · `ford_pavement`)이 곧 범위다.
 * 서버 짝 = `B06_Section_Router_Design.paved_at` · 저장값 · 카드 선택은 쓰지 않는다.
 */
export function pavedBySpecs(section: Pick<CrossSection, "pavement" | "ford_pavement">): boolean {
  return Boolean(section.pavement?.length) || Boolean(section.ford_pavement);
}

function preserveUserFields(
  next: NonNullable<CrossSection["design"]>,
  previous: CrossSection["design"],
): NonNullable<CrossSection["design"]> {
  if (!previous) return next;
  const merged = { ...next } as Record<string, unknown>;
  const source = previous as unknown as Record<string, unknown>;
  for (const key of PRESERVED_KEYS) {
    if (source[key] !== undefined) merged[key] = source[key];
  }
  return merged as unknown as NonNullable<CrossSection["design"]>;
}

/**
 * 계획선 한 벌(342-1) — 종단도가 화면에 그린 선(서버 측점 대신 관 지점 · 옮긴 꼭짓점)을 맡겨 두는 자리.
 * 다시 셈이 저장분 선으로 계획고를 적으면 그리기 판정(화면 선)과 mm 단위로 갈려 늘 낡음이 됐다
 * (유토곡선 「다시 계산하는 중」 머묾 · 341 부록 2 4장). B05 · B06 · 3D 가 모두 이 선을 받는다.
 */
type ScreenLine = (routeId: number) => ProfileAlignment | null;
let screenLine: ScreenLine | null = null;

/** 종단도가 자기 선을 맡김 — 돌려준 함수로 거둠(자기 것일 때만). */
export function holdScreenAlignment(line: ScreenLine): () => void {
  screenLine = line;
  return () => {
    if (screenLine === line) screenLine = null;
  };
}

/** 낡음 판정을 화면 선 기준으로 — 저장분 선끼리 견주면 화면과 반대 판정이 났다(341 부록 2 4장). */
export function staleAgainstScreen(detail: SectionDetailResponse, routeId: number): boolean {
  const screen = screenLine?.(routeId);
  if (!screen) return hasStaleDesigns(detail);
  return hasStaleDesigns({
    longitudinal: {
      design_profiles: [toDesignProfile(screen, detail.longitudinal.design_profiles?.[0])],
    },
    cross_sections: detail.cross_sections,
  });
}

/**
 * 전 측점 횡단을 현재 계획선으로 다시 계산해 `detail.cross_sections[].design`을 제자리 교체한다.
 * 돌려주는 값은 설계 · 면적이 실제로 바뀐 측점의 누가거리 목록 — 호출한 쪽이 그 카드만 다시 그리면 된다.
 * 부르는 곳은 계산 묶음 cross 단계 하나(`design_shared` savedCross · 387-4) — 화면은 `pipelineCross` 로 부탁.
 * 계획선 ▲ 한 번에 값이 바뀌는 측점은 몇 개뿐 — 전부 돌려주면 카드를 다 갈아 끼워 멈춤(54-22).
 */
export async function refreshCrossDesigns(input: CrossRefreshInput): Promise<number[]> {
  // 노선 초안 동안 묶음 새 노선 상세(측점 모두 `preview`) = 묶음 cross 결과 그대로 — 브라우저 다시 셈이 다른
  // 값을 안 냄(넓힌 표본 · 화면 선이 다름 · 349-0o). 관 · 구조물 초안이 미리 뜬 측점 몇 개(`preview`)는 다시 셈
  const sections = input.detail.cross_sections;
  if (sections.length && sections.every((section) => section.preview)) return [];
  useStationKeys(input.projectId, input.routeId, input.detail); // 세션 고침을 이 측점 목록으로 읽음(344-3)
  const before = new Map(sections.map((section) => [section, JSON.stringify(section.design)]));
  if (!refreshLocally(input)) await refreshFromServer(input);
  // 구조물이 선 측점은 폐회로 면적이 정본이다 — **이 자리 한 곳**에서 늘 다시 얹는다(387-4 · 카드 그리기는
  // 안 얹음 · 설계가 그대로여도 조정창 4축 · 구조물 제원이 바뀌면 면적이 바뀜 · 6 ms/67 측점).
  applyStructureAreaRows(
    input.detail.cross_sections,
    structureAreaRows(input.detail.cross_sections),
  );
  return sections
    .filter((section) => JSON.stringify(section.design) !== before.get(section))
    .map((section) => section.chainage_m);
}

/**
 * 암 경계 세션 오프셋을 **자릿수에 안 휘둘리게** 읽는다.
 *
 * 저장하는 쪽(`createRockBoundaryStore`)은 키를 `toFixed(2)` 로 쓰고, 서버는 받은 키를
 * 숫자로 바꿔 비교했다. 로컬 계산이 문자열 키를 그대로 맞추려다 자릿수가 달라 세션값을
 * 통째로 놓쳤고, 그래서 B06 을 다녀오기 전과 후의 절·성토가 달랐다(2026-09-03 실측
 * 성토 16,715.5㎥ ↔ 16,690.7㎥). 키를 숫자로 되돌려 0.01m 단위로 맞춘다.
 */
function rockKey(chainageM: number): number {
  return Math.round(chainageM * 100) / 100;
}

function readRockOffsets(projectId: string, routeId: number): Map<number, number> {
  const raw = readRockBoundarySession(projectId, routeId) ?? {};
  const offsets = new Map<number, number>();
  for (const [key, value] of Object.entries(raw)) {
    const chainage = Number(key);
    if (Number.isFinite(chainage) && typeof value === "number" && Number.isFinite(value)) {
      offsets.set(rockKey(chainage), value);
    }
  }
  return offsets;
}

/**
 * 소단 구간을 **측점별 제원**으로 편다 — 서버는 측점키로 받기 때문이다.
 * 구간 자체는 세션에 그대로 두어 「어디부터 어디까지 놓았나」를 잃지 않는다.
 */
function bermPayload(
  projectId: string,
  routeId: number,
  detail: SectionDetailResponse,
): Record<string, BermSessionSpec & Partial<Record<`berm_depth_${Side}_m`, number>>> {
  const spans = readBermSpans(projectId, routeId);
  const out: Record<string, BermSessionSpec & Partial<Record<`berm_depth_${Side}_m`, number>>> = {};
  if (!spans.length) return out;
  const depthAt = bermDepthReader(projectId, routeId);
  for (const section of detail.cross_sections) {
    const spec = bermSpecAt(spans, section.chainage_m);
    if (!spec) continue;
    const design = (section.design ?? {}) as Record<string, unknown>;
    const sides: Partial<Record<`berm_depth_${Side}_m`, number>> = {};
    for (const side of SIDES) {
      const own = depthAt(section.chainage_m, design, side);
      if (own !== null) sides[`berm_depth_${side}_m`] = own;
    }
    out[rockKey(section.chainage_m).toFixed(2)] = { ...spec, ...sides };
  }
  return out;
}

type Side = "left" | "right";
const SIDES: Side[] = ["left", "right"];

/** 소단 쪽마다 옮긴 깊이(194-1) — 세션 → 저장분 순 · 없으면 null(구간 깊이를 씀). */
function bermDepthReader(projectId: string, routeId: number) {
  const session = readBermDepths(projectId, routeId);
  return (chainageM: number, design: Record<string, unknown>, side: Side): number | null => {
    const own = session.get(rockKey(chainageM))?.[side];
    const stored = design[`berm_depth_${side}_m`];
    const value = own ?? (typeof stored === "number" ? stored : null);
    return value === null ? null : Math.max(value, 0);
  };
}

/**
 * 측점별 암 절토 경사비 세션값 — 암 경계선(`readRockOffsets`)과 같은 방식으로 읽는다.
 *
 * **0 은 「표준값을 씀」**이다(되돌리기). 그래서 0 을 거르지 않고 그대로 싣는다 — 거르면
 * 저장분에 남은 옛 사용자 값이 되살아난다.
 */
function readCutSlopeRatios(projectId: string, routeId: number): Map<number, number> {
  const out = new Map<number, number>();
  const raw = readCutSlopeSession(projectId, routeId);
  for (const [chainage, ratio] of Object.entries(raw)) {
    const at = Number(chainage);
    if (Number.isFinite(at) && Number.isFinite(ratio) && ratio >= 0) out.set(rockKey(at), ratio);
  }
  return out;
}

/**
 * 브라우저 안에서 전 측점을 다시 계산한다(정상 경로).
 *
 * 계획고는 저장된 자동 선형(`profile_alignment.base_pvi`)에 편집 델타를 얹어 **여기서**
 * 푼다 — B05 편집 중에는 `detail.longitudinal.design_profiles` 가 아직 옛 계획선이라
 * 그걸 쓰면 한 박자 늦은 값이 된다. 계산 재료(선형 저장분·표준단면)를 갖추지 못하면
 * `null` 을 돌려 서버 폴백으로 넘긴다.
 */
/** 측점별 앞 계산 — 측점 객체가 바뀌면(상세 다시 받음) 저절로 비워진다. */
const memos = new WeakMap<
  CrossSection,
  { samples: CrossSection["samples"]; fingerprint: string; design: CrossSection["design"] }
>();

function refreshLocally(input: CrossRefreshInput): number[] | null {
  const { projectId, detail, edits } = input;
  const stored = readAlignment(detail.longitudinal);
  // 선 = 화면이 쥔 선 → 종단도가 맡긴 선 → 저장분 + 편집(종단도가 아직 없을 때) · 342-1
  const alignment =
    input.alignment ??
    screenLine?.(input.routeId) ??
    (stored
      ? buildAlignment(toAlignmentBase(stored), {
          station_offsets: edits.station_offsets ?? {},
          curve_radii: edits.curve_radii ?? {},
        })
      : null);
  if (!alignment) return null; // 선형 저장분이 없는 옛 데이터 — 서버가 풀어 준다.
  const standard = effectiveStandardCross(projectId) as StandardCrossSectionSpec | null;
  if (!standard) return null; // 컨텍스트를 아직 못 받음 — 이번만 서버로.
  const standardKey = JSON.stringify(standard);
  // 방금 푼 계획선을 **공유 캐시에도 얹는다**. 여기서 만드는 횡단 설계는 편집이 반영된
  // 계획고 기준인데 `design_profiles` 만 저장분으로 남으면 두 값의 기준이 어긋나, 낡음
  // 판정이 영원히 참이 되어 유토곡선이 빈 채로 남는다(2026-09-03 사용자 보고: B05 편집 중
  // 문구만 뜸 → B06 유토곡선 영역 누락). `profile_alignment`(base_pvi)는 **건드리지 않는다**
  // — 편집 델타의 기준선이라 편집분을 구워 넣으면 다음 편집에서 이중 적용된다.
  detail.longitudinal.design_profiles = [
    toDesignProfile(alignment, detail.longitudinal.design_profiles?.[0]),
  ];

  const rockOffsets = readRockOffsets(projectId, input.routeId);
  const rockDefault = readRockBoundaryDefault(projectId);
  // 측점별 암 절토 경사도 세션에만 있는 값이다 — **계산 전에** 실어야 설계선이 새 경사로
  // 그려진다. 계산 뒤에 값만 베껴 붙이면 그림은 옛 경사, 숫자만 새것이 된다(2026-09-07).
  const cutSlopeRatios = readCutSlopeRatios(projectId, input.routeId);
  // 소단도 같은 성격 — 세션에만 있는 값이라 여기서 실어 주지 않으면 계획선을 고치는
  // 순간 계단이 사라진다(계획서 3-9).
  const bermSpans = readBermSpans(projectId, input.routeId);
  const bermDepthAt = bermDepthReader(projectId, input.routeId);
  const bermAt = (chainageM: number, design: Record<string, unknown>): BermSpec | null => {
    const spec = bermSpecAt(bermSpans, chainageM);
    return spec
      ? {
          widthM: spec.width_m,
          intervalM: spec.interval_m,
          slopeDeg: spec.slope_deg,
          depthM: spec.depth_m,
          // 쪽마다 옮긴 깊이(194-1) — 세션 → 저장분
          depthLeftM: bermDepthAt(chainageM, design, "left"),
          depthRightM: bermDepthAt(chainageM, design, "right"),
        }
      : null;
  };
  // 카드 버튼 선택은 세션 초안이 정본보다 새것이다 — 새로고침 뒤에도 고른 값이 남는다
  // (2026-09-06 사용자 확정: 조작은 캐시, 저장은 [저장]·[확정]).
  /** 세션 → 저장분 순. 없거나 0(되돌림)이면 null 을 줘 표준값을 쓰게 한다. */
  const cutSlopeAt = (chainageM: number, design: Record<string, unknown>): number | null => {
    const session = cutSlopeRatios.get(rockKey(chainageM));
    if (session !== undefined) return session > 0 ? session : null;
    const stored = design.cut_slope_ratio_user;
    return typeof stored === "number" && stored > 0 ? stored : null;
  };
  const choices = crossDesignChoices(projectId, input.routeId);
  const choiceAt = (chainageM: number) => choices.get(Math.round(chainageM * 100) / 100);
  // 노견 확장(139-6) — 세션 → 저장분 순 · 기하 입력이라 계산에 넣고 결과 칸도 그 값으로
  const shoulderExtends = readShoulderExtends(projectId, input.routeId);
  const extendAt = (chainageM: number, design: Record<string, unknown>, side: "left" | "right") => {
    const session = shoulderExtends.get(Math.round(chainageM * 100) / 100)?.[side];
    const stored = design[`shoulder_extend_${side}_m`];
    return Math.max(session ?? (typeof stored === "number" ? stored : 0), 0);
  };

  const updated: number[] = [];
  for (const section of detail.cross_sections) {
    const previous = section.design;
    if (!previous) continue; // 설계가 없는 측점은 서버 기본 설계가 붙을 때까지 둔다.
    const design = previous as unknown as Record<string, unknown>;
    // 암 경계는 세션 조정값 → 저장분 → config 기본값 순 — 서버
    // `recompute_designs_for_alignment` 의 우선순위와 같다.
    const sessionOffset = rockOffsets.get(rockKey(section.chainage_m));
    const storedOffset = design.rock_boundary_offset_m;
    const rockBoundaryOffsetM =
      typeof sessionOffset === "number"
        ? sessionOffset
        : typeof storedOffset === "number"
          ? storedOffset
          : rockDefault;
    const choice = choiceAt(section.chainage_m);
    const extendLeft = extendAt(section.chainage_m, design, "left");
    const extendRight = extendAt(section.chainage_m, design, "right");
    const elevation = planElevationAt(alignment, section.chainage_m);
    const options: CrossDesignOptions = {
      groundType:
        choice?.ground_type ??
        (typeof design.ground_type === "string" ? design.ground_type : "ripping_rock"),
      sectionMode:
        choice?.section_mode ??
        (typeof design.section_mode === "string" ? design.section_mode : "left_cut"),
      ditchSide:
        choice?.ditch_side ?? (typeof design.ditch_side === "string" ? design.ditch_side : null),
      // 저장분은 측구가 없으면 `ditch_type: null` 이다 — 서버와 같이 기본형으로 되돌린다.
      ditchType:
        choice?.ditch_type ??
        (typeof design.ditch_type === "string" ? design.ditch_type : "standard"),
      paved: pavedBySpecs(section),
      // 물넘이 자리 = 측구 없음 · 지대 낮은 쪽 한 경사(286-2 · 287-4 · 서버 `tilt_ranges` 짝 = 얹힌 제원)
      tilted: Boolean(section.ford_pavement || section.underdrain),
      tiltPct: section.ford_pavement?.slope_pct ?? null, // 맹암거 = 표준 경사(371-3)
      standard,
      berm: bermAt(section.chainage_m, design),
      rockBoundaryOffsetM,
      cutSlopeRatio: cutSlopeAt(section.chainage_m, design),
      twoStageSlope: choice?.two_stage_slope ?? Boolean(design.two_stage_slope),
      // ⚠ **선택과 결과를 갈라 넘긴다**(2026-09-09). 선택이 있으면 그것을 따르고,
      //   없으면 옛 저장분의 결과를 **자동값과 다를 때만** 선택으로 살린다.
      ditchChoice: choice
        ? (choice.ditch_choice ?? null)
        : typeof design.ditch_choice === "boolean"
          ? design.ditch_choice
          : null,
      ditchEnabled: typeof design.ditch_enabled === "boolean" ? design.ditch_enabled : null,
      // 세월교 월류 하강 = 그 측점에 얹힌 세월교 제원(초안 · 저장분 같은 자리 · 서버 `ford_drop_at` 짝 · 314)
      surfaceDropM:
        Number(section.ford?.overflow_depth_m) > 0 ? Number(section.ford?.overflow_depth_m) : 0,
      // 곡선부 확폭 입력 — 측점 기록에 실려 온다(서버 엔진과 같은 값, 2026-09-06).
      planRadiusM: section.plan_radius_m ?? null,
      curveOuterSide:
        section.curve_outer_side === "left" || section.curve_outer_side === "right"
          ? section.curve_outer_side
          : null,
      curveWideningM: section.curve_widening_m ?? null,
      shoulderExtendLeftM: extendLeft,
      shoulderExtendRightM: extendRight,
    };
    // 국부 연산(346-2) — 입력 지문(지반 표본 · 계획고 · 횡단 입력 · 구조물 맥락 · 표준값)이 같고
    // 설계가 그때 낸 그 객체면 앞 결과 그대로. 계획고 ▲ 한 번에 다시 세는 측점은 곡선 둘레 몇 곳뿐.
    const samples = section.samples ?? [];
    const fingerprint = `${standardKey}|${elevation}|${samples.length}|${JSON.stringify({ ...options, standard: null })}`;
    const memo = memos.get(section);
    if (
      memo?.samples === section.samples &&
      memo.fingerprint === fingerprint &&
      memo.design === previous
    ) {
      continue;
    }
    let next;
    try {
      next = computeCrossDesign(samples, elevation, options);
    } catch {
      continue; // 샘플 부족·값 손상 측점은 건너뛴다(서버 엔진과 같은 태도).
    }
    section.design = preserveUserFields(
      next as unknown as NonNullable<CrossSection["design"]>,
      previous,
    );
    section.design.shoulder_extend_left_m = extendLeft;
    section.design.shoulder_extend_right_m = extendRight;
    // 옮긴 소단 깊이 = 새 계산이 되실은 값(옛 값 승계보다 세션이 새것 · 194-1)
    for (const side of SIDES) {
      const own = next[`berm_depth_${side}_m`];
      if (typeof own === "number") section.design[`berm_depth_${side}_m`] = own;
    }
    memos.set(section, { samples: section.samples, fingerprint, design: section.design });
    updated.push(section.chainage_m);
  }
  return updated;
}

/** 옛 데이터 폴백 — 선형 저장분이 없어 브라우저가 계획고를 풀 수 없을 때만 쓴다. */
async function refreshFromServer(input: CrossRefreshInput): Promise<number[]> {
  const { projectId, routeId, detail, edits, shouldApply } = input;
  const response = await previewCrossDesigns(
    projectId,
    routeId,
    edits,
    readStandardCrossSession(projectId) ?? undefined,
    {
      fullDesigns: true,
      rockBoundaryOffsets: readRockBoundarySession(projectId, routeId),
      berms: bermPayload(projectId, routeId, detail),
      // 측점별 암 절토 경사도 세션값이라 함께 싣는다 — 안 실으면 서버 폴백에서만
      // 사용자 경사가 조용히 표준값으로 되돌아간다(2026-09-07).
      cutSlopeRatios: readCutSlopeSession(projectId, routeId),
    },
  );
  if (shouldApply && !shouldApply()) return [];
  const designByChainage = new Map(
    response.designs.map((entry) => [entry.chainage_m.toFixed(3), entry.design]),
  );
  const updated: number[] = [];
  for (const section of detail.cross_sections) {
    const next = designByChainage.get(section.chainage_m.toFixed(3));
    if (!next) continue;
    section.design = preserveUserFields(
      next as NonNullable<CrossSection["design"]>,
      section.design,
    );
    updated.push(section.chainage_m);
  }
  return updated;
}