@things-factory/headless-twin 10.1.278 → 10.1.279

package/server/service/twin-space/move-space.ts

@@ -1,262 +0,0 @@
-/*
- * 이미 있는 트윈을 다른 현장으로 옮긴다 — **판정만**. 순수.
- *
- * ── 왜 있나 (2026-08-13) ────────────────────────────────────────────────────
- * 트윈↔현장 연결은 **만들 때만** 정할 수 있었다(템플릿 위자드·import 의 `spaceId`). 잘못 넣었거나,
- * 나중에 "이 창고는 사실 저 공장과 같은 부지다" 를 알게 되면 지우고 다시 만드는 것이 유일한 길이었다 —
- * 다시 만들면 그 트윈의 저널(일어난 일)이 사라진다. 고칠 수 있는 실수를 데이터 손실로 갚게 하는 설계다.
- *
- * ── 옮기는 것이 무엇을 옮기나 (엔티티 키를 보고 정했다) ──────────────────────
- * 무엇이 트윈에 매여 있고 무엇이 공간에 매여 있는지가 답을 정한다:
- *
- *  · `TwinEvent`         `(domain, instanceId, …)`  → **따라온다.** 저널을 다시 쓰지 않는다.
- *  · `TwinLocation/Equipment/Operation`  `(domain, instance, …)`  → **따라온다.**
- *  · `TwinArea`          `(domain, space, areaId)`  → **남는다.** 구역은 공간의 것이다.
- *  · `TwinSpaceRepresentation`(지도·이미지·보드)     → **남는다.** 표현도 공간의 것이다.
- *
- * 그래서 옮기기는 이력 이전이 아니라 **소속 갱신**이다(`instance.spaceId` + `model.spaceId`).
- * 대신 공간에 매인 것들과의 연결이 끊길 수 있고, 그것을 **알리지 않고 넘기지 않는 것**이 이 모듈의 일이다.
- *
- * ── 거절과 경고를 가른다 ────────────────────────────────────────────────────
- * 거절: 되돌릴 수 없거나 뜻이 성립하지 않는 것(없는 공간·같은 공간·벤치 사본).
- * 경고: 사용자가 알고 나면 정당할 수 있는 것(구역 소속이 끊긴다·시간대가 다르다·옛 표현이 남는다).
- * 경고를 거절로 올리면 정당한 이전을 막고, 거절을 경고로 낮추면 들어온 것이 없는 사고가 된다.
- */
-
-/** 옮길 수 없는 이유 — 언어 중립 코드(발견 오류·인제스트 거절과 같은 규약). */
-export type MoveSpaceRefusalCode = 'twin-not-found' | 'space-not-found' | 'same-space' | 'bench-copy'
-
-/** 옮겨도 되지만 알아야 하는 것 — 같은 규약. */
-export type MoveSpaceWarningCode = 'areas-left-behind' | 'timezone-differs' | 'representations-left-behind' | 'running'
-
-export interface MoveSpaceNote<C extends string> {
-  code: C
-  params?: Record<string, string | number>
-  /** 영어 canonical — 로그에 남고, 번역이 없으면 그대로 보인다. */
-  message: string
-}
-
-export type MoveSpaceRefusal = MoveSpaceNote<MoveSpaceRefusalCode>
-export type MoveSpaceWarning = MoveSpaceNote<MoveSpaceWarningCode>
-
-export interface MoveSpaceInput {
-  /** 옮길 트윈. 없으면 거절한다. */
-  instanceId?: string
-  /** 지금 속한 공간(없을 수 있다 — 옛 트윈). */
-  fromSpaceId?: string
-  /** 옮겨 갈 공간. */
-  toSpaceId: string
-  /** 그 공간이 이 테넌트에 실제로 있나(호출측이 조회해 넘긴다). */
-  toSpaceExists: boolean
-  /** 운영 트윈인가 벤치 사본인가 — 사본은 원본의 공간을 따라야 하므로 옮기지 않는다. */
-  purpose?: string
-  /** 지금 실행 중인가 — 시간대 변화는 재기동 뒤에 커널에 실린다. */
-  running?: boolean
-  /** 두 공간의 시간대(IANA). 다르면 앞으로의 시각 해석이 달라진다. */
-  fromTimezone?: string
-  toTimezone?: string
-  /** 이 트윈의 로케이션들이 소속으로 가리키는 구역 id 들(중복 포함 가능). */
-  areaRefs?: readonly (string | undefined | null)[]
-  /** 옮겨 갈 공간에 있는 구역 id 들. */
-  toAreaIds?: readonly string[]
-  /** 옛 공간의 표현 수 — 그 표현의 폴리곤이 이 트윈을 가리키고 있었을 수 있다. */
-  fromRepresentationCount?: number
-}
-
-export interface MoveSpaceJudgement {
-  /** 있으면 옮기지 않는다. */
-  refusal?: MoveSpaceRefusal
-  /** 옮기되 함께 알린다. 비어 있으면 잃는 것이 없다. */
-  warnings: MoveSpaceWarning[]
-}
-
-/** 옮겨도 되나 — 되면 무엇을 알려야 하나. */
-export function judgeMoveTwinSpace(input: MoveSpaceInput): MoveSpaceJudgement {
-  const to = (input.toSpaceId ?? '').trim()
-  const from = (input.fromSpaceId ?? '').trim()
-
-  if (!input.instanceId) {
-    return {
-      refusal: { code: 'twin-not-found', message: 'no such twin in this tenant' },
-      warnings: []
-    }
-  }
-  if (!to || !input.toSpaceExists) {
-    return {
-      refusal: {
-        code: 'space-not-found',
-        params: { spaceId: to },
-        message: `space "${to}" not found — cannot move a twin into a space that does not exist`
-      },
-      warnings: []
-    }
-  }
-  if (from && from === to) {
-    return {
-      refusal: {
-        code: 'same-space',
-        params: { spaceId: to },
-        message: `twin "${input.instanceId}" is already in space "${to}"`
-      },
-      warnings: []
-    }
-  }
-  /* 벤치 사본은 "이 공장이 이만큼 커지면" 을 재는 사본이라 원본의 현장에 매여 있다. 옮기면 그 측정이
-     무엇의 측정인지 말할 수 없게 된다 — 사본을 옮기는 대신 원본을 옮기고 사본을 다시 뜬다. */
-  if (input.purpose === 'bench') {
-    return {
-      refusal: {
-        code: 'bench-copy',
-        params: { instanceId: input.instanceId },
-        message: `twin "${input.instanceId}" is a bench copy — move its source twin instead`
-      },
-      warnings: []
-    }
-  }
-
-  const warnings: MoveSpaceWarning[] = []
-
-  /* 로케이션의 구역 소속 — 구역은 공간의 것이라 새 공간에 같은 id 가 없으면 소속이 끊긴다.
-     막지는 않는다(새 공간에서 구역을 다시 그리는 것이 정상 경로다). 다만 몇 개가 끊기는지 말한다. */
-  const refs = [...new Set((input.areaRefs ?? []).filter((x): x is string => !!x && !!x.trim()))]
-  const have = new Set(input.toAreaIds ?? [])
-  const orphaned = refs.filter(r => !have.has(r)).sort()
-  if (orphaned.length) {
-    warnings.push({
-      code: 'areas-left-behind',
-      params: { count: orphaned.length, areas: orphaned.slice(0, 5).join(', ') },
-      message: `${orphaned.length} area reference(s) do not exist in the target space — those locations lose their grouping: ${orphaned
-        .slice(0, 5)
-        .join(', ')}`
-    })
-  }
-
-  /* 시간대 — 공간이 정하고 커널이 분 오프셋으로 받는다. 다르면 같은 저널이 다른 시각으로 읽힌다. */
-  const tzFrom = (input.fromTimezone ?? '').trim()
-  const tzTo = (input.toTimezone ?? '').trim()
-  if (tzFrom !== tzTo) {
-    warnings.push({
-      code: 'timezone-differs',
-      params: { from: tzFrom || '—', to: tzTo || '—' },
-      message: `time zone changes from "${tzFrom || 'unset'}" to "${tzTo || 'unset'}" — shift boundaries and day buckets will read differently`
-    })
-  }
-
-  /* 옛 공간의 표현 — 폴리곤 바인딩이 이 트윈의 로케이션·그룹을 가리키고 있었을 수 있다. 표현은
-     공간에 남으므로, 그 화면에서 이 트윈이 사라진다. 몇 개가 남는지 말해 두면 사람이 찾아갈 수 있다. */
-  if ((input.fromRepresentationCount ?? 0) > 0) {
-    warnings.push({
-      code: 'representations-left-behind',
-      params: { count: input.fromRepresentationCount as number, spaceId: from || '—' },
-      message: `${input.fromRepresentationCount} representation(s) stay with space "${from}" — bindings that pointed at this twin will no longer resolve there`
-    })
-  }
-
-  /* 실행 중 — 소속은 즉시 바뀌지만 시간대는 커널을 세울 때 실린다. 시간대가 같으면 말할 것이 없다. */
-  if (input.running && tzFrom !== tzTo) {
-    warnings.push({
-      code: 'running',
-      params: { instanceId: input.instanceId },
-      message: `twin "${input.instanceId}" is running — the new time zone applies after it is restarted`
-    })
-  }
-
-  return { warnings }
-}
-
-/*
- * ── 현장에서 떼기 (2026-08-13) ──────────────────────────────────────────────
- *
- * 더하기·옮기기만 있으면 잘못 넣은 것을 되돌릴 수 없다. 떼기는 "어느 현장에도 속하지 않음" 으로
- * 되돌리는 일이고, 데이터 모델이 그 상태를 이미 허용한다(`TwinInstance.spaceId` 는 선택 컬럼).
- *
- * 떼면 무엇이 달라지나 — 옮기기와 같은 규칙이지만 **갈 곳이 없다**는 점이 다르다:
- *  · 저널·로케이션·설비는 그대로 트윈에 남는다(잃는 것 없음).
- *  · 구역·표현은 옛 현장에 남는다 → 그 화면에서 이 트윈이 사라진다.
- *  · **볼 무대가 없어진다** — 현장 현황(지도·보드)은 현장의 표현으로 그리므로, 뗀 트윈은 목록과
- *    조회 화면에서만 보인다. 이것을 말하지 않으면 사용자는 트윈이 고장 났다고 읽는다.
- *  · 시간 기준(`utcOffsetMinutes`)은 **옛 현장의 것으로 남는다.** 지우면 알리지 않고 UTC 로 읽히므로
- *    그쪽이 더 위험하다 — 남기고 그 사실을 말한다.
- */
-
-/** 뗄 수 없는 이유 — 언어 중립 코드. */
-export type DetachSpaceRefusalCode = 'twin-not-found' | 'no-space' | 'bench-copy'
-
-/** 떼도 되지만 알아야 하는 것. */
-export type DetachSpaceWarningCode = 'no-stage' | 'representations-left-behind' | 'timebase-kept'
-
-export type DetachSpaceRefusal = MoveSpaceNote<DetachSpaceRefusalCode>
-export type DetachSpaceWarning = MoveSpaceNote<DetachSpaceWarningCode>
-
-export interface DetachSpaceInput {
-  instanceId?: string
-  /** 지금 속한 공간 — 없으면 뗄 것이 없다. */
-  fromSpaceId?: string
-  purpose?: string
-  /** 옛 공간의 표현 수. */
-  fromRepresentationCount?: number
-  /** 옛 공간의 시간대 — 있으면 그 기준이 model 에 남는다. */
-  fromTimezone?: string
-}
-
-export interface DetachSpaceJudgement {
-  refusal?: DetachSpaceRefusal
-  warnings: DetachSpaceWarning[]
-}
-
-/** 떼도 되나 — 되면 무엇을 알려야 하나. */
-export function judgeDetachTwinSpace(input: DetachSpaceInput): DetachSpaceJudgement {
-  const from = (input.fromSpaceId ?? '').trim()
-
-  if (!input.instanceId) {
-    return { refusal: { code: 'twin-not-found', message: 'no such twin in this tenant' }, warnings: [] }
-  }
-  if (!from) {
-    return {
-      refusal: {
-        code: 'no-space',
-        params: { instanceId: input.instanceId },
-        message: `twin "${input.instanceId}" is not on any site — nothing to detach`
-      },
-      warnings: []
-    }
-  }
-  /* 벤치 사본은 원본의 현장을 따라야 측정이 무엇의 측정인지 말할 수 있다(옮기기와 같은 이유). */
-  if (input.purpose === 'bench') {
-    return {
-      refusal: {
-        code: 'bench-copy',
-        params: { instanceId: input.instanceId },
-        message: `twin "${input.instanceId}" is a bench copy — it must stay on the site it measures`
-      },
-      warnings: []
-    }
-  }
-
-  const warnings: DetachSpaceWarning[] = [
-    {
-      code: 'no-stage',
-      params: { instanceId: input.instanceId },
-      message: `twin "${input.instanceId}" will have no site to be drawn on — it stays visible in lists and inspection only`
-    }
-  ]
-
-  if ((input.fromRepresentationCount ?? 0) > 0) {
-    warnings.push({
-      code: 'representations-left-behind',
-      params: { count: input.fromRepresentationCount as number, spaceId: from },
-      message: `${input.fromRepresentationCount} representation(s) stay with space "${from}" — bindings that pointed at this twin will no longer resolve there`
-    })
-  }
-
-  const tz = (input.fromTimezone ?? '').trim()
-  if (tz) {
-    warnings.push({
-      code: 'timebase-kept',
-      params: { timezone: tz },
-      message: `the time base stays as "${tz}" (the site it came from) — clearing it would silently read times as UTC`
-    })
-  }
-
-  return { warnings }
-}

package/server/service/twin-space/representation-role.ts

@@ -1,15 +0,0 @@
-/*
- * 표현이 무엇을 위한 것인가 — **닫힌 목록** (2026-08-27 · 사용자 지시).
- *
- *   index      표현 목록에 나온다. 비어 있으면 이것이다(흔한 쪽을 기본으로 둔다)
- *   derived    다른 표현에서 열린다(팝업·드릴 대상). 목록에서는 접어 세어 보인다 — 감추지 않는다
- *
- * 열어 두면 넣는 쪽마다 다른 이름을 쓰고, 그러면 화면이 어느 이름을 목록에 넣어야 하는지 알 수 없다.
- * 늘려야 하면 이 목록에 더한다.
- *
- * ── 왜 엔티티가 아니라 이 파일인가 ──────────────────────────────────────────
- * 엔티티에는 데코레이터가 있어서 테스트가 그 파일을 읽을 수 없다(런타임의 타입 제거가 데코레이터를
- * 파싱하지 못한다). 값으로 확인해야 하는 것은 데코레이터 없는 파일에 둔다.
- */
-export const REPRESENTATION_ROLES = ['index', 'derived'] as const
-export type RepresentationRole = (typeof REPRESENTATION_ROLES)[number]

package/server/service/twin-space/space-integrity.ts

@@ -1,293 +0,0 @@
-/*
- * 공간 ↔ 트윈 ↔ 가시화 정합성 — **순수**. 세 축이 서로 어긋난 자리를 찾는다.
- *
- * ── 왜 있나 (2026-08-13) ────────────────────────────────────────────────────
- * 이 셋은 서로를 id 로만 가리킨다. 참조 무결성을 DB 가 지켜 주지 않는 지점이 많다:
- * 공간·구역은 공간에 매이고, 로케이션·설비는 트윈에 매이고, 폴리곤은 **양쪽을 가리킨다.**
- * 그래서 트윈을 옮기거나 떼거나(2026-08-13 추가) 원본을 다시 읽으면, 아무 오류 없이 **가리킬 것이
- * 없는 도형**과 **소속 없는 로케이션**이 남는다. 증상은 "지도가 비었다" 뿐이고 원인은 화면에 없다.
- *
- * 그 어긋남을 사람이 눈으로 맞추고 있었다(spaceId 를 목록에서 대조). 기계가 대신 본다.
- *
- * ── 무엇을 사실로 보나 ─────────────────────────────────────────────────────
- * 판정은 **조회 결과만** 받는다(DB 를 물지 않는다). 그래서 단위테스트로 전부 부를 수 있고, 호출측은
- * 사실을 모으는 일만 한다. 각 발견은 언어 중립 코드 + 파라미터이고, 화면이 사람 말을 만든다.
- *
- * ── 심각도를 가른다 ────────────────────────────────────────────────────────
- * `broken` 은 무언가 이미 보이지 않는 상태다(가리킬 대상이 없다). `warn` 은 아직 보이지만 뜻이
- * 흐려진 상태다(소속 없음·대표 없음). 섞으면 사람이 무엇을 먼저 볼지 정할 수 없다.
- */
-
-export type SpaceIntegrityCode =
-  /** 트윈이 없는 공간을 가리킨다 — 그 트윈은 무대가 사라졌다. */
-  | 'twin-space-missing'
-  /** 레지스트리와 model 의 공간이 다르다 — 어느 쪽이 사실인지 알 수 없다. */
-  | 'twin-space-mismatch'
-  /** 폴리곤이 이 공간에 없는 구역을 가리킨다. */
-  | 'polygon-area-missing'
-  /** 폴리곤이 이 공간에 사는 어느 트윈에도 없는 로케이션·설비를 가리킨다. */
-  | 'polygon-target-missing'
-  /** 로케이션이 이 공간에 없는 구역에 소속되어 있다. */
-  | 'location-area-missing'
-  /** 대표 표현이 이 공간의 표현이 아니다. */
-  | 'primary-representation-missing'
-  /** 보드 표현이 보드를 가리키지 않는다(또는 없는 보드를 가리킨다). */
-  | 'board-representation-unbound'
-  /** 표현이 하나도 없는 공간에 트윈이 산다 — 볼 화면이 없다. */
-  | 'space-without-representation'
-  /** 어느 공간에도 속하지 않은 트윈 — 뗀 결과일 수 있다(사실이면 정상). */
-  | 'twin-without-space'
-  /**
-   * 이 트윈이 **담을 줄 모르는 어휘**를 받고 있다 — 리비전은 오르는데 상태가 채워지지 않는다.
-   *
-   * 커널은 모르는 `eventType` 을 버리고(전방 호환) 종류별로 센다(`state.unhandled`). 그 수가 0이
-   * 아니면 둘 중 하나다: 커넥터가 엉뚱한 트윈에 붙었거나(예: `energy.*` 가 창고 트윈으로), 커널이
-   * 낡아 새 어휘를 모른다. 둘 다 사람이 손봐야 하는 것이고, 알리지 않고 두면 「정상인데 빈」 트윈이 된다.
-   */
-  | 'twin-unhandled-vocabulary'
-
-export type SpaceIntegritySeverity = 'broken' | 'warn'
-
-export interface SpaceIntegrityFinding {
-  code: SpaceIntegrityCode
-  severity: SpaceIntegritySeverity
-  /** 어디의 문제인가 — 화면이 그 자리로 데려갈 수 있게. */
-  spaceId?: string
-  instanceId?: string
-  representationId?: string
-  params?: Record<string, string | number>
-  /** 영어 canonical — 로그·폴백. */
-  message: string
-}
-
-/* ── 입력(조회 결과) ──────────────────────────────────────────────────────── */
-
-export interface IntegritySpace {
-  spaceId: string
-  primaryRepresentationId?: string | null
-}
-
-export interface IntegrityInstance {
-  instanceId: string
-  /** 레지스트리 컬럼. */
-  spaceId?: string | null
-  /** 저장된 model 의 공간 — 레지스트리와 같아야 한다. */
-  modelSpaceId?: string | null
-  purpose?: string | null
-  /** 이 트윈의 로케이션 id 들. */
-  locationIds?: readonly string[]
-  /** 이 트윈의 설비 id 들. */
-  equipmentIds?: readonly string[]
-  /** 로케이션의 소속 구역 id 들(중복 가능). */
-  areaRefs?: readonly (string | undefined | null)[]
-  /**
-   * 커널이 담을 줄 몰라 버린 사건들 — 실행 중인 트윈의 상태에서 온다(`state.unhandled`).
-   *
-   * 정지한 트윈에서는 알 수 없으므로 `undefined` 다 — **없는 것과 모르는 것을 구별한다**(빈 배열을
-   * 넣으면 「받은 것이 없다」는 사실 주장이 되고, 그것은 우리가 확인한 바가 아니다).
-   */
-  unhandled?: readonly { eventType: string; count: number }[]
-}
-
-export interface IntegrityRepresentation {
-  id: string
-  spaceId: string
-  type: string
-  /** 보드 표현이면 보드 id. */
-  boardId?: string | null
-  /** 폴리곤 바인딩들. */
-  polygons?: readonly IntegrityPolygon[]
-}
-
-export interface IntegrityPolygon {
-  id?: string
-  /** 논리 구역 바인딩(그룹). */
-  groupId?: string | null
-  /** 개체 바인딩 — 로케이션 또는 설비. */
-  targetKind?: 'location' | 'equipment' | null
-  targetId?: string | null
-}
-
-export interface SpaceIntegrityInput {
-  spaces: readonly IntegritySpace[]
-  instances: readonly IntegrityInstance[]
-  representations: readonly IntegrityRepresentation[]
-  /** 공간별 구역 id 들. */
-  areasBySpace: Readonly<Record<string, readonly string[]>>
-  /** 존재하는 보드 id 들 — 보드 표현이 실제 보드를 가리키는지 본다. */
-  boardIds?: readonly string[]
-}
-
-/** 세 축을 맞대어 어긋난 자리를 모두 낸다. 비어 있으면 정합하다. */
-export function checkSpaceIntegrity(input: SpaceIntegrityInput): SpaceIntegrityFinding[] {
-  const out: SpaceIntegrityFinding[] = []
-  const spaceIds = new Set(input.spaces.map(s => s.spaceId))
-  const areasOf = (spaceId: string) => new Set(input.areasBySpace[spaceId] ?? [])
-  const repsOf = (spaceId: string) => input.representations.filter(r => r.spaceId === spaceId)
-  const boards = new Set(input.boardIds ?? [])
-
-  /* 벤치 사본은 측정용 사본이라 이 검사의 대상이 아니다 — 사본의 공간은 잠깐 살고 지워진다. */
-  const instances = input.instances.filter(i => i.purpose !== 'bench')
-
-  /* ── 트윈 → 공간 ─────────────────────────────────────────────────────── */
-  for (const t of instances) {
-    const sid = (t.spaceId ?? '').trim()
-    const msid = (t.modelSpaceId ?? '').trim()
-
-    if (!sid) {
-      out.push({
-        code: 'twin-without-space',
-        severity: 'warn',
-        instanceId: t.instanceId,
-        message: `twin "${t.instanceId}" is on no site — it has no map or board to be drawn on`
-      })
-    } else if (!spaceIds.has(sid)) {
-      out.push({
-        code: 'twin-space-missing',
-        severity: 'broken',
-        instanceId: t.instanceId,
-        spaceId: sid,
-        message: `twin "${t.instanceId}" points at site "${sid}" which does not exist`
-      })
-    }
-
-    /* 두 곳이 어긋나면 어느 쪽이 사실인지 알 수 없다 — 보드는 model 을, 목록은 컬럼을 읽는다. */
-    if (sid !== msid) {
-      out.push({
-        code: 'twin-space-mismatch',
-        severity: 'broken',
-        instanceId: t.instanceId,
-        spaceId: sid || undefined,
-        params: { registry: sid || '—', model: msid || '—' },
-        message: `twin "${t.instanceId}" registry site "${sid || 'none'}" differs from its model site "${msid || 'none'}"`
-      })
-    }
-
-    /* 로케이션의 소속 구역은 **트윈이 속한 공간**의 것이어야 한다. */
-    if (sid && spaceIds.has(sid)) {
-      const have = areasOf(sid)
-      const refs = [...new Set((t.areaRefs ?? []).filter((x): x is string => !!x && !!x.trim()))]
-      const missing = refs.filter(r => !have.has(r)).sort()
-      if (missing.length) {
-        out.push({
-          code: 'location-area-missing',
-          severity: 'warn',
-          instanceId: t.instanceId,
-          spaceId: sid,
-          params: { count: missing.length, areas: missing.slice(0, 5).join(', ') },
-          message: `${missing.length} area(s) referenced by locations of "${t.instanceId}" do not exist in site "${sid}": ${missing
-            .slice(0, 5)
-            .join(', ')}`
-        })
-      }
-    }
-
-    /*
-     * 어휘가 맞는가 — 저널이 들어오는데 상태가 채워지지 않는 경우를 잡는다.
-     *
-     * `undefined` 는 「모른다」다(정지한 트윈). 세지 않는다 — 확인하지 않은 것을 정합으로도, 결함으로도
-     * 세지 않는 것이 이 하네스의 규율이다.
-     */
-    if (t.unhandled?.length) {
-      const total = t.unhandled.reduce((n, u) => n + u.count, 0)
-      const kinds = [...t.unhandled].sort((a, b) => b.count - a.count)
-      out.push({
-        code: 'twin-unhandled-vocabulary',
-        severity: 'warn',
-        instanceId: t.instanceId,
-        spaceId: sid || undefined,
-        params: { events: total, kinds: kinds.length, types: kinds.slice(0, 3).map(u => u.eventType).join(', ') },
-        message: `twin "${t.instanceId}" received ${total} event(s) of ${kinds.length} type(s) its kernel does not handle: ${kinds
-          .slice(0, 3)
-          .map(u => u.eventType)
-          .join(', ')}`
-      })
-    }
-  }
-
-  /* ── 공간 → 가시화 ───────────────────────────────────────────────────── */
-  for (const s of input.spaces) {
-    const reps = repsOf(s.spaceId)
-    const livesHere = instances.filter(t => (t.spaceId ?? '') === s.spaceId)
-
-    /* 트윈이 사는데 표현이 없으면 볼 화면이 없다. 트윈이 없는 빈 현장은 정상이므로 세지 않는다. */
-    if (livesHere.length && !reps.length) {
-      out.push({
-        code: 'space-without-representation',
-        severity: 'warn',
-        spaceId: s.spaceId,
-        params: { twins: livesHere.length },
-        message: `site "${s.spaceId}" has ${livesHere.length} twin(s) but no representation — there is nothing to draw them on`
-      })
-    }
-
-    const primary = (s.primaryRepresentationId ?? '').trim()
-    if (primary && !reps.some(r => r.id === primary)) {
-      out.push({
-        code: 'primary-representation-missing',
-        severity: 'broken',
-        spaceId: s.spaceId,
-        params: { representationId: primary },
-        message: `site "${s.spaceId}" points at primary representation "${primary}" which is not one of its representations`
-      })
-    }
-  }
-
-  /* ── 가시화 → 공간·트윈 ─────────────────────────────────────────────── */
-  for (const rep of input.representations) {
-    const have = areasOf(rep.spaceId)
-    /* 이 공간에 사는 트윈들의 개체 id — 폴리곤이 가리킬 수 있는 전부. */
-    const here = instances.filter(t => (t.spaceId ?? '') === rep.spaceId)
-    const locationIds = new Set(here.flatMap(t => [...(t.locationIds ?? [])]))
-    const equipmentIds = new Set(here.flatMap(t => [...(t.equipmentIds ?? [])]))
-
-    if (rep.type === 'board' && !(rep.boardId && boards.has(rep.boardId))) {
-      out.push({
-        code: 'board-representation-unbound',
-        severity: 'broken',
-        spaceId: rep.spaceId,
-        representationId: rep.id,
-        params: { boardId: rep.boardId ?? '—' },
-        message: `board representation "${rep.id}" of site "${rep.spaceId}" does not point at an existing board (${rep.boardId ?? 'none'})`
-      })
-    }
-
-    for (const p of rep.polygons ?? []) {
-      const gid = (p.groupId ?? '').trim()
-      if (gid && !have.has(gid)) {
-        out.push({
-          code: 'polygon-area-missing',
-          severity: 'broken',
-          spaceId: rep.spaceId,
-          representationId: rep.id,
-          params: { areaId: gid, polygonId: p.id ?? '—' },
-          message: `a polygon of representation "${rep.id}" binds area "${gid}" which does not exist in site "${rep.spaceId}"`
-        })
-      }
-      const tid = (p.targetId ?? '').trim()
-      if (tid && p.targetKind) {
-        const pool = p.targetKind === 'equipment' ? equipmentIds : locationIds
-        if (!pool.has(tid)) {
-          out.push({
-            code: 'polygon-target-missing',
-            severity: 'broken',
-            spaceId: rep.spaceId,
-            representationId: rep.id,
-            params: { kind: p.targetKind, targetId: tid, polygonId: p.id ?? '—' },
-            message: `a polygon of representation "${rep.id}" binds ${p.targetKind} "${tid}", which no twin on site "${rep.spaceId}" has`
-          })
-        }
-      }
-    }
-  }
-
-  return out
-}
-
-/** 심각한 것부터 — 화면이 정렬을 다시 정하지 않게 한 곳에서 정한다. */
-export function sortFindings(findings: readonly SpaceIntegrityFinding[]): SpaceIntegrityFinding[] {
-  const rank = (s: SpaceIntegritySeverity) => (s === 'broken' ? 0 : 1)
-  return [...findings].sort(
-    (a, b) => rank(a.severity) - rank(b.severity) || a.code.localeCompare(b.code) || (a.spaceId ?? '').localeCompare(b.spaceId ?? '')
-  )
-}

package/server/service/twin-space/twin-area.ts

@@ -1,63 +0,0 @@
-import { CreateDateColumn, Entity, Index, Column, RelationId, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { Domain, ScalarObject } from '@things-factory/shell'
-
-import { TwinSpace } from './twin-space.js'
-
-/*
- * TwinArea — 공간의 **논리적 구역(계층)**. 표현 무관(ISA-95 building→floor→zone).
- * area 단일화(space #2): deprecated `TwinSpace.content.areas`(blob) 를 정규화한 영구 자리.
- * 표현별 폴리곤(`TwinSpaceArea`)은 이 논리 구역을 `areaId` 로 참조한다(P2에서 binding.groupId→areaId 전환).
- * 안전 순서: P1=신설+인제스트 dual-write(content.areas 병행 유지) → P2 소비처 전환 → P3 blob 제거.
- */
-@Entity()
-@Index('ix_twin_area_0', (e: TwinArea) => [e.domain, e.space, e.areaId], { unique: true })
-@ObjectType({ description: 'A logical (representation-agnostic) area in a space hierarchy (building/floor/zone). Polygons reference it by areaId.' })
-export class TwinArea {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { nullable: true, description: 'Owning tenant domain.' })
-  domain?: Domain
-
-  @RelationId((e: TwinArea) => e.domain)
-  domainId?: string
-
-  @ManyToOne(type => TwinSpace)
-  @Field(type => TwinSpace, { nullable: true, description: 'Owning space.' })
-  space?: TwinSpace
-
-  @RelationId((e: TwinArea) => e.space)
-  spaceRowId?: string
-
-  @Column()
-  @Field({ description: 'Stable logical area id (unique within a space). Polygons reference this via areaId.' })
-  areaId: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Area name.' })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Region type (building/floor/zone/yard/dock…).' })
-  type?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Parent logical area id (hierarchy). Root areas have none.' })
-  parentId?: string
-
-  @Column({ type: 'simple-json', nullable: true })
-  @Field(type => ScalarObject, { nullable: true, description: 'Layout footprint hint { x, y, w, h } in design coords (representation-agnostic).' })
-  layout?: any
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-}