@things-factory/headless-twin 10.1.278 → 10.1.280

package/server/engine/stage-path.ts

@@ -1,172 +0,0 @@
-/*
- * 단계 판정 — **가벼운 성공을 최종 성공으로 잇는 길을, 사람의 체크가 아니라 증거로 센다.**
- *
- * ── 왜 이 모듈이 있나 ───────────────────────────────────────────────────────
- * 트윈 도입은 「구조 → 라이브 → 예측 → 폐루프」로 간다. 그런데 이 진행을 **체크리스트**로 관리하면
- * 사람이 체크하는 순간 참이 된다. 실제로 가장 자주 건너뛰어지는 자리가 구조 다음이다 — 구조가 서면
- * 화면이 그럴듯해지므로 「실시간」이라고 말해 버리고, 되풀어 읽는 스냅샷이 그 말을 뒷받침하지 못한다.
- *
- * 그래서 단계를 **판정식**으로 둔다. 각 단계는 시스템이 이미 내놓는 사실로만 판정되고, 선언으로
- * 위조할 수 없다. 특히:
- *
- *  · **반출 관측**이 라이브의 판별식이다. 스냅샷을 되풀어 읽는 방식은 **원리적으로** 반출을 낼 수 없다
- *    (사라진 것은 그냥 없어질 뿐이라 `OBSERVE` 만 남는다). 그러므로 「반출을 한 번이라도 계산했는가」는
- *    진짜 delta 의 증거이고, 폴링을 실시간이라 부르는 것을 막는다.
- *  · **선언 적재량**이 예측의 판별식이다. 커널 기본값으로 돌아간 예측도 숫자를 내므로, 화면만 보면
- *    구별되지 않는다. 그 숫자가 무엇 위에 섰는지는 `specCoverage` 만 안다.
- *
- * ── 이 모듈의 정수: 「모른다」를 「아니다」로도 「그렇다」로도 바꾸지 않는다 ──────────────
- * 계측되지 않은 신호는 `null` 로 온다. `null` 은 0 이 아니다. 계측되지 않았으면 그 단계는 **달성이
- * 아니고**, 그 사실을 `unmeasured` 로 말한다 — 신호를 배선하지 않은 채 단계를 주장할 길을 남기지
- * 않는다. (0 으로 대체하면 「반출 0건」과 「반출을 세지 않았다」가 같아진다.)
- *
- * 순수 함수다(프레임워크·DB 무의존) — 증거 수집은 호출자 몫이다.
- */
-
-export type StageId = 'structure' | 'live' | 'forecast' | 'closed-loop'
-
-/** 판정에 쓰는 사실. `null` = **계측되지 않았다**(0 이 아니다). */
-export interface StageEvidence {
-  /* ── S1 구조 ── */
-  /** 이 트윈이 든 자리 수. */
-  locationCount: number
-  /** 자리에 놓인 물품 수(비직렬 수량 물품 포함 — 식품·화학은 개수가 아니라 총량으로 온다). */
-  itemCount: number
-  /**
-   * 마스터를 옮기며 **못 옮긴 값의 수**. `null` = 세지 않았다.
-   *
-   * 0 이면 통과이고 n 이어도 통과다 — 이 판정이 요구하는 것은 「없다」가 아니라 **「말할 수 있다」**다.
-   * 못 옮긴 값을 세지 않은 구조 인제스트는 도크를 랙으로 바꿔 놓고도 성공이라 답하면서 아무 일도 하지 않는다.
-   */
-  masterWarnings: number | null
-  /**
-   * 이 축이 이 트윈에 **해당하나**. 레퍼런스 없이 템플릿으로 세운 트윈에는 옮겨 온 마스터가 없으므로
-   * 「못 옮긴 값」을 물을 대상이 아니다 — 그걸 미측정으로 처리하면 영원히 배선을 기다린다.
-   */
-  masterWarningsApplicable?: boolean
-
-  /* ── S2 라이브 ── */
-  /** 인제스트 누적 건수. */
-  liveIngestTotal: number
-  /** **반출(remove)을 계산한 누적 건수.** `null` = 계측되지 않음. 0 = 세었으나 없었다(→ 스냅샷 의심). */
-  removalsObserved: number | null
-
-  /* ── S3 예측 ── */
-  /** 이 트윈에서 예측이 한 번이라도 돌았나. */
-  forecastRan: boolean
-  /** 선언 적재량 — `declared`/`total`. `null` = 알 수 없음. */
-  specCoverage: { declared: number; total: number } | null
-
-  /* ── S4 폐루프 ── */
-  /**
-   * 이 트윈이 **무엇인가** — 시뮬레이션은 원천에서 받는 것이 없다.
-   *
-   * 시뮬에 라이브를 요구하면 영원히 빨갛고, 그 빨강은 결함이 아니다. 도입 단계는 **연결된 트윈**의
-   * 축이므로 시뮬은 라이브 이후를 「해당 없음」으로 말한다(달성으로도, 미측정으로도 계산하지 않는다).
-   */
-  subject?: 'live' | 'sim'
-  /** 피드 성격 — `snapshot-poll` 이면 반출 0 은 「아직」이 아니라 **구조적으로 불가**다. */
-  feed?: 'push' | 'delta-poll' | 'snapshot-poll' | 'none' | 'unknown'
-  /** 원본이 **선언∩구현**으로 액추에이션 능력을 갖나(`capabilitiesOf`). */
-  actuateCapability: boolean
-  /** 내 명령의 효과가 인바운드로 **상관되어** 돌아온 누적 건수. `null` = 계측되지 않음. */
-  correlatedEffectObserved: number | null
-}
-
-export interface StageVerdict {
-  id: StageId
-  achieved: boolean
-  /** 아직 아닌 이유 — 언어중립 코드(화면이 옮긴다). 달성이면 빈 배열. */
-  blockedBy: string[]
-  /** 판정할 수 없었던 신호 — **배선되지 않은 계측**. 있으면 달성이 아니다. */
-  unmeasured: string[]
-}
-
-export interface StagePath {
-  stages: StageVerdict[]
-  /** 지금 서 있는 칸 — 연속으로 달성된 마지막 단계. 하나도 없으면 `null`. */
-  reached: StageId | null
-  /**
-   * 다음 한 걸음 — 사람이 오늘 할 수 있는 일 하나. 없으면(전부 달성) `null`.
-   * 「무엇이 부족한지」의 목록이 아니라 **다음 하나**다. 목록은 사람을 멈추게 한다.
-   */
-  next: { stage: StageId; blockedBy: string[]; unmeasured: string[] } | null
-}
-
-const ORDER: StageId[] = ['structure', 'live', 'forecast', 'closed-loop']
-
-/**
- * 증거로 단계를 판정한다.
- *
- * **단계는 앞선 단계를 전제한다**(구조 없이 라이브를 달성했다고 말할 수 없다). 앞이 막히면 뒤는
- * 자기 조건을 따지지 않고 `prerequisite` 으로 막는다 — 뒤 단계의 조건을 나열하면 사람이 순서를
- * 건너뛴다.
- */
-export function assessStagePath(e: StageEvidence): StagePath {
-  const stages: StageVerdict[] = []
-  let prereqOk = true
-
-  for (const id of ORDER) {
-    const blockedBy: string[] = []
-    const unmeasured: string[] = []
-
-    if (!prereqOk) {
-      blockedBy.push('prerequisite')
-    } else if (id === 'structure') {
-      if (!(e.locationCount > 0)) blockedBy.push('no-locations')
-      if (!(e.itemCount > 0)) blockedBy.push('no-items')
-      if (e.masterWarningsApplicable !== false && e.masterWarnings === null) unmeasured.push('master-warnings')
-    } else if (id === 'live') {
-      if (e.subject === 'sim') blockedBy.push('subject-is-simulation')
-      else {
-        if (!(e.liveIngestTotal > 0)) blockedBy.push('no-ingest')
-        if (e.removalsObserved === null) unmeasured.push('removals')
-        /*
-         * 세었는데 없다. 이유가 둘이고 **처방이 정반대**다: 스냅샷을 되풀어 읽는 방식이면 더 기다려도
-         * 오지 않으므로 방식을 바꿔야 하고, 그 밖이면 아직 반출이 일어나지 않은 것일 수 있다.
-         */
-        else if (e.removalsObserved === 0) blockedBy.push(e.feed === 'snapshot-poll' ? 'snapshot-only-feed' : 'no-removal-observed')
-      }
-    } else if (id === 'forecast') {
-      if (!e.forecastRan) blockedBy.push('no-forecast-run')
-      if (e.specCoverage === null) unmeasured.push('spec-coverage')
-      /* 선언이 0 이면 예측은 커널 기본값 위에 섰다 — 숫자는 나오지만 이 현장의 숫자가 아니다. */
-      else if (!(e.specCoverage.declared > 0)) blockedBy.push('declarations-empty')
-    } else {
-      if (!e.actuateCapability) blockedBy.push('no-actuate-capability')
-      if (e.correlatedEffectObserved === null) unmeasured.push('correlated-effect')
-      /* 접수만으로는 폐루프가 아니다 — 효과가 관측으로 돌아와야 닫힌다. */
-      else if (!(e.correlatedEffectObserved > 0)) blockedBy.push('effect-not-observed')
-    }
-
-    const achieved = blockedBy.length === 0 && unmeasured.length === 0
-    stages.push({ id, achieved, blockedBy, unmeasured })
-    if (!achieved) prereqOk = false
-  }
-
-  const achievedIds = stages.filter(s => s.achieved).map(s => s.id)
-  const firstUnmet = stages.find(s => !s.achieved)
-  return {
-    stages,
-    reached: achievedIds.length ? achievedIds[achievedIds.length - 1] : null,
-    next: firstUnmet ? { stage: firstUnmet.id, blockedBy: firstUnmet.blockedBy, unmeasured: firstUnmet.unmeasured } : null
-  }
-}
-
-/**
- * 이 단계에 이르지 못했다면 **쓰지 않기로 한 말**.
- *
- * 근거 수준 규율(`connector-developer-guide` §8)을 판정과 같은 자리에 둔다. 문장이 문서에만 있으면
- * 제안서를 쓰는 사람이 그 문서를 읽지 않는다. 값이 되면 화면이 그 자리에서 말할 수 있다.
- */
-export const CLAIM_GATE: Record<StageId, string> = {
-  structure: 'claim.structure-synced',
-  live: 'claim.realtime',
-  forecast: 'claim.prediction',
-  'closed-loop': 'claim.automatic-control'
-}
-
-/** 아직 쓸 수 없는 주장들 — 도달하지 못한 단계의 게이트 전부. */
-export function forbiddenClaims(path: StagePath): string[] {
-  return path.stages.filter(s => !s.achieved).map(s => CLAIM_GATE[s.id])
-}

package/server/engine/state-axes.ts

@@ -1,60 +0,0 @@
-/*
- * 상태 축 고르기 — **순수**. "요청한 축만 남긴다."
- *
- * ── 왜 있나 (2026-08-05) ────────────────────────────────────────────────────
- * 지도는 구독으로 "바뀌었다" 신호를 받고 상태를 다시 읽는다. 그 신호는 의도적으로 가볍고(`{kind,
- * revision}`) 리프레시도 250ms 로 합쳐진다 — 거기까지는 설계대로다. 문제는 **리프레시가 통째로**
- * 라는 것이다: 실 저널로 재 보니 트윈 하나가 최대 710KB 이고, 같은 공간에 셋이면 한 번에 약 2MB 다.
- *
- * 그런데 지도가 실제로 쓰는 것은 `locations`·`attentions`·`nowTime` **셋뿐**이다(코드 확인). 물품
- * 2,278건·작업·오더를 받아 놓고 쓰지 않는다. 축을 골라 받으면 트윈에 따라 1.7~15배 줄어든다
- * (물품이 많은 트윈은 15배, 신호가 많은 트윈은 2배 — 신호가 큰 쪽은 그것이 다음 과제다).
- *
- * ── 화면 이름을 API 에 넣지 않는다 ──────────────────────────────────────────
- * `twinMapState` 같은 화면 전용 질의를 만들지 않는다. 호출부가 **필요한 축을 말하고** 서버가 자른다 —
- * 새 화면이 생길 때마다 질의가 늘지 않고, 어휘도 화면 이름이 아니라 상태의 축이다(무방언).
- *
- * 모르는 축 이름은 **알리지 않고 버리지 않고 무시하되 그 사실을 돌려준다** — 오타 하나로 화면이 빈
- * 채로 뜨는 것이 가장 나쁘다.
- */
-
-/**
- * 상태가 들고 있는 축 — 이 목록 밖의 이름은 고를 수 없다.
- *
- * `energy` 는 에너지 트윈만 채운다(계량 지점·수요 구간·피크). `ALWAYS` 에 두지 않는다: 마감 구간을
- * 하루치 들고 있어 작지 않고, 그것이 필요한 화면이 스스로 이름을 말하는 편이 맞다.
- */
-export const STATE_AXES = ['locations', 'items', 'equipment', 'persons', 'assets', 'tasks', 'orders', 'attentions', 'acked', 'energy'] as const
-export type StateAxis = (typeof STATE_AXES)[number]
-
-/** 축과 무관하게 늘 남는 것 — 이것이 없으면 무엇을 받았는지 알 수 없다. */
-const ALWAYS = ['revision', 'nowTime', 'simClockMs', 'corrections', 'unhandled'] as const
-
-export interface PickedAxes {
-  /** 고른 축만 남은 상태. `axes` 가 비었으면 원본 그대로(자르지 않는다). */
-  state: any
-  /** 상태 축이 아닌 이름 — 호출부가 오타를 알 수 있게 돌려준다. */
-  unknown: string[]
-}
-
-/**
- * 요청한 축만 남긴다.
- *
- * `axes` 가 비어 있으면 **자르지 않는다** — 기본값이 "전부" 여야 기존 호출부가 그대로 동작한다
- * (자르는 쪽이 기본이면 축을 말하지 않은 화면이 알리지 않고 비어 버린다).
- */
-export function pickAxes(state: any, axes: readonly string[] | undefined | null): PickedAxes {
-  if (!state || typeof state !== 'object') return { state, unknown: [] }
-  if (!axes?.length) return { state, unknown: [] }
-
-  const known = new Set<string>(STATE_AXES as readonly string[])
-  const wanted = axes.filter(a => known.has(a))
-  const unknown = axes.filter(a => !known.has(a))
-  /* 아는 축이 하나도 없으면 자르지 않는다 — 전부 오타인 경우에 빈 화면을 만들지 않는다. */
-  if (!wanted.length) return { state, unknown }
-
-  const out: any = {}
-  for (const k of ALWAYS) if (k in state) out[k] = state[k]
-  for (const a of wanted) if (a in state) out[a] = state[a]
-  return { state: out, unknown }
-}

package/server/engine/structure-diff.ts

@@ -1,88 +0,0 @@
-/*
- * 구조 이력의 **차이** — "2번째에 도장 부스가 넷 늘었다" 를 말할 수 있게.
- *
- * 리비전은 그 시절 공장을 통째로 담는다(재생하려면 전체 위상이 필요하다). 그런데 사람이 보고 싶은
- * 것은 통째가 아니라 **무엇이 달라졌나** 다 — 62KB 짜리 모델 두 개를 나란히 놓고 눈으로 비교할 수는
- * 없다. 그 한 줄을 여기서 만든다.
- *
- * 순수 함수인 이유: 같은 문장을 화면과 AI 가 함께 써야 한다. 한쪽에서만 계산하면 둘이 다른 말을 한다.
- */
-
-/** 종류별 증감 — "paint-booth +4" 처럼 읽힌다. */
-export interface StructureCountChange {
-  key: string
-  before: number
-  after: number
-  delta: number
-}
-
-export interface StructureDiff {
-  /** 자리 종류별 증감(0 인 것은 빼고). */
-  locationTypes: StructureCountChange[]
-  /** 설비 종류별 증감(0 인 것은 빼고). */
-  equipmentKinds: StructureCountChange[]
-  locationsAdded: number
-  locationsRemoved: number
-  equipmentAdded: number
-  equipmentRemoved: number
-  /** 개수는 같은데 내용이 바뀐 경우(용량 조정·자리 이동 등)가 있는가. */
-  changedInPlace: boolean
-}
-
-const countBy = <T>(rows: readonly T[] | undefined, key: (r: T) => string | undefined): Map<string, number> => {
-  const out = new Map<string, number>()
-  for (const r of rows ?? []) {
-    const k = key(r)
-    if (k) out.set(k, (out.get(k) ?? 0) + 1)
-  }
-  return out
-}
-
-const idsOf = (rows: readonly { id?: string }[] | undefined): Set<string> => new Set((rows ?? []).map(r => r.id).filter((x): x is string => !!x))
-
-function changes(before: Map<string, number>, after: Map<string, number>): StructureCountChange[] {
-  const keys = [...new Set([...before.keys(), ...after.keys()])].sort()
-  return keys
-    .map(key => ({ key, before: before.get(key) ?? 0, after: after.get(key) ?? 0, delta: (after.get(key) ?? 0) - (before.get(key) ?? 0) }))
-    .filter(c => c.delta !== 0)
-}
-
-/**
- * 두 구조의 차이. `before` 가 없으면 **최초 리비전**이라 비교 대상이 없다 — 전부 새로 생긴 것으로 센다.
- *
- * 아이디는 **집합으로** 비교한다(수만 세면 넷이 사라지고 넷이 생긴 교체를 "변화 없음" 으로 답한다).
- */
-export function diffStructures(before: any | undefined, after: any): StructureDiff {
-  const beforeLocations = before?.locations ?? []
-  const beforeEquipment = before?.equipment ?? []
-  const afterLocations = after?.locations ?? []
-  const afterEquipment = after?.equipment ?? []
-
-  const beforeLocationIds = idsOf(beforeLocations)
-  const afterLocationIds = idsOf(afterLocations)
-  const beforeEquipmentIds = idsOf(beforeEquipment)
-  const afterEquipmentIds = idsOf(afterEquipment)
-
-  const added = <T>(a: Set<T>, b: Set<T>) => [...b].filter(x => !a.has(x)).length
-  const locationsAdded = added(beforeLocationIds, afterLocationIds)
-  const locationsRemoved = added(afterLocationIds, beforeLocationIds)
-  const equipmentAdded = added(beforeEquipmentIds, afterEquipmentIds)
-  const equipmentRemoved = added(afterEquipmentIds, beforeEquipmentIds)
-
-  /*
-   * 아이디는 그대로인데 속성이 바뀐 경우 — 용량을 늘렸거나 설비를 옮겼다. 지문이 달라 새 리비전이
-   * 생겼는데 증감이 전부 0 이면, 화면이 "바뀐 게 없다" 고 답하게 된다. 그런 침묵을 막는다.
-   */
-  const changedInPlace =
-    !locationsAdded && !locationsRemoved && !equipmentAdded && !equipmentRemoved && !!before
-
-  return {
-    locationTypes: changes(countBy(beforeLocations, (n: any) => n.type), countBy(afterLocations, (n: any) => n.type)),
-    equipmentKinds: changes(countBy(beforeEquipment, (m: any) => m.kind), countBy(afterEquipment, (m: any) => m.kind)),
-    locationsAdded,
-    locationsRemoved,
-    equipmentAdded,
-    equipmentRemoved,
-    changedInPlace
-  }
-}

package/server/engine/travel-estimator.ts

@@ -1,138 +0,0 @@
-/*
- * 이동시간 추정기 — **거리 × 속도.** 커널의 `TRAVEL_MS` 상수를 대체하는 유일한 정당한 길.
- *
- * 커널은 좌표를 모른다(설계: 좌표-free — "얼마 걸리나" 만 소비하고 "어떤 경로로" 는 씬 소관).
- * 그래서 거리 기반 계산은 **호스트가 추정기로 주입**한다(`DurationEstimator` 시임).
- *
- * 좌표는 이미 있다: 마스터의 `RefLocation.footprint` → `masterToTwin` 이 `model.layout`(노드 중심)으로
- * 낸다. 없던 것은 **속도**다 — 속도 없이 거리만으로는 시간이 나오지 않는다. 그래서 설비 속성
- * (ISA-95 `EquipmentSpecificationProperty`)으로 받는다.
- *
- * 정직 규율: **셋 중 하나라도 모르면 답하지 않는다**(undefined → 커널이 명세·상수로 떨어진다).
- *  ① 두 노드의 좌표 ② 그 작업을 할 자원 종류의 속도 ③ 좌표의 단위가 미터인지
- * 그리고 같은 노드 안의 작업(처리·체류)은 이동이 아니므로 다루지 않는다 — 거리 0 을 "0초" 로
- * 만들면 공정 시간이 사라진다.
- */
-
-import type { MeasuredEstimate } from './measured-estimator.js'
-
-/**
- * UN/CEFACT 권고 20 공통코드 → m/s 변환. 모르는 코드는 변환하지 않는다(발명 금지).
- *
- * **내보내는 이유**: 선언 화면·AI 가 「어떤 단위를 받나」를 말해야 하고, 그 목록이 두 곳에 적히면
- * 화면이 받아 준 단위를 추정기가 모르는 일이 생긴다(그때 공정 시간이 오류 없이 사라진다).
- */
-export const SPEED_TO_MPS: Record<string, number> = {
-  MTS: 1, // metre per second
-  KMH: 1000 / 3600, // kilometre per hour
-  '2M': 0.3048, // foot per second
-  HM: 0.44704 // mile per hour
-}
-
-/** 우리가 읽는 canonical 설비 속성 ID — 표준이 속성 ID 어휘를 정하지 않으므로 한 곳에서 정한다. */
-export const EQUIPMENT_PROPERTY = { speed: 'speed' } as const
-
-/** 추정기 문맥 — 커널 `DurationContext` 와 같은 모양(커널 타입에 의존하지 않기 위해 구조로 맞춘다). */
-export interface DurationCtx {
-  kind: string
-  fromNode: string
-  toNode: string
-  resourceKind?: string
-}
-
-/**
- * 추정기 — 숫자(평균만) 또는 추정치 객체(퍼짐까지). 커널 `DurationEstimator` 와 같은 모양.
- * 거리 계산은 숫자를 내고, 실측은 관측된 퍼짐을 함께 낸다.
- */
-export interface DurationEstimatorLike {
-  estimate(ctx: DurationCtx): number | MeasuredEstimate | undefined
-}
-
-export interface TravelEstimatorInput {
-  /** 노드 중심 좌표(masterToTwin 산출 `model.layout`). */
-  layout?: Record<string, { x: number; y: number }>
-  /** 무버(자원) — kind 와 속성. `model.equipment`. */
-  equipment?: { id: string; kind: string; properties?: { id: string; value: string; uom?: string }[] }[]
-  /** 좌표 단위(공간 `content.unit`). 미터가 아니면 계산하지 않는다(환산을 추측하지 않는다). */
-  unit?: string
-}
-
-export interface TravelEstimatorResult {
-  estimator?: { estimate(ctx: DurationCtx): number | undefined }
-  /** 왜 못 만들었나(만들었으면 비어 있음) — 알리지 않고 없는 상태로 두지 않는다. */
-  reasons: string[]
-  /** 속도를 읽어낸 자원 종류들 — 무엇이 계산 대상인지 드러낸다. */
-  speedsByKind: Record<string, number>
-}
-
-/** 자원 종류별 속도(m/s) — 같은 종류에 값이 여럿이면 첫 유효값. 단위 없는 속도는 받지 않는다. */
-function readSpeeds(equipment: TravelEstimatorInput['equipment'], reasons: string[]): Record<string, number> {
-  const out: Record<string, number> = {}
-  for (const m of equipment ?? []) {
-    if (out[m.kind] !== undefined) continue
-    const p = m.properties?.find(x => x.id === EQUIPMENT_PROPERTY.speed)
-    if (!p) continue
-    const n = Number(p.value)
-    if (!Number.isFinite(n) || n <= 0) { reasons.push(`equipment "${m.id}": speed "${p.value}" is not a positive number`); continue }
-    /* 단위가 없으면 m/s 라고 **가정하지 않는다** — 3 이 초속 3m 인지 시속 3km 인지 뜻이 완전히 다르다. */
-    if (!p.uom) { reasons.push(`equipment "${m.id}": speed has no unit of measure (expected UN/CEFACT code such as MTS or KMH)`); continue }
-    const factor = SPEED_TO_MPS[p.uom]
-    if (factor === undefined) { reasons.push(`equipment "${m.id}": unknown speed unit "${p.uom}"`); continue }
-    out[m.kind] = n * factor
-  }
-  return out
-}
-
-/**
- * 이동시간 추정기를 만든다 — 만들 수 없으면 **이유와 함께** 비운다.
- * `estimator` 가 undefined 면 커널은 명세·상수로 굴러가고, `reasons` 가 왜 그런지 말한다.
- */
-export function buildTravelEstimator(input: TravelEstimatorInput): TravelEstimatorResult {
-  const reasons: string[] = []
-  const layout = input.layout
-  const unit = input.unit ?? 'm'
-  if (unit !== 'm') reasons.push(`space unit is "${unit}", not metres — travel time is not computed (no assumed conversion)`)
-  if (!layout || !Object.keys(layout).length) reasons.push('no location coordinates (model.layout empty) — travel time cannot be derived from distance')
-  const speedsByKind = readSpeeds(input.equipment, reasons)
-  if (!Object.keys(speedsByKind).length) reasons.push('no resource declares a speed property — distance alone cannot produce a duration')
-  if (reasons.length) return { reasons, speedsByKind }
-
-  const lay = layout as Record<string, { x: number; y: number }>
-  return {
-    reasons,
-    speedsByKind,
-    estimator: {
-      estimate(ctx) {
-        /* 같은 자리에서 벌어지는 일(처리·체류)은 이동이 아니다 — 다루지 않고 넘긴다. */
-        if (!ctx.fromNode || !ctx.toNode || ctx.fromNode === ctx.toNode) return undefined
-        const a = lay[ctx.fromNode]
-        const b = lay[ctx.toNode]
-        if (!a || !b) return undefined // 좌표를 모르는 노드(관측으로 알게 된 자리 등)
-        const speed = ctx.resourceKind ? speedsByKind[ctx.resourceKind] : undefined
-        if (!speed) return undefined // 자원 종류를 모르거나 그 종류의 속도가 없다
-        const dist = Math.hypot(b.x - a.x, b.y - a.y)
-        if (!Number.isFinite(dist) || dist <= 0) return undefined
-        return Math.round((dist / speed) * 1000)
-      }
-    }
-  }
-}
-
-/**
- * 추정기 사슬 — 앞선 것이 답하면 그 값, 아니면 다음. **실측 → 계산 → (커널이) 명세 → 상수** 순서를
- * 이 사슬과 커널 `durationOf` 가 함께 만든다. 앞에 둘수록 강한 근거다.
- */
-export function chainEstimators(estimators: (DurationEstimatorLike | undefined)[]): DurationEstimatorLike | undefined {
-  const live = estimators.filter(Boolean) as DurationEstimatorLike[]
-  if (!live.length) return undefined
-  if (live.length === 1) return live[0]
-  return {
-    estimate(ctx) {
-      for (const e of live) {
-        const v = e.estimate(ctx)
-        if (v !== undefined) return v
-      }
-      return undefined
-    }
-  }
-}