@things-factory/headless-twin 10.0.19 → 10.1.0

package/test/intake-mapping-parity.test.ts

@@ -0,0 +1,175 @@
+/*
+ * ★ **접수 타입에 있는 칸은 매핑도 옮긴다** — 문턱에서 조용히 버려지던 자리.
+ *
+ * ── 오늘 이 부류가 일곱 번이었다 (2026-09-04) ──────────────────────────────
+ *   ActuationAck 이 세 칸을 버린다고 말한다     타입과 값 사이
+ *   save 가 새 칸을 안 쓴다                    칸과 쓰는 길
+ *   질의가 noteNext 를 안 낸다                 저장과 화면 사이
+ *   커넥터가 등급 셋을 읽어 놓고 버린다          원본 쪽
+ *   homeLocation vs homeLocationId            낱말 하나
+ *   equipmentClassIds 칸이 접수면에 없다        ← 이 검사가 막는 것
+ *   materialActual 안쪽을 안 본다               검사가 얕다
+ *
+ * **일곱 다 오류가 안 나서** 검사로만 잡혔다.
+ *
+ * ── 이 자리가 특히 조용하다 ─────────────────────────────────────────────────
+ * 접수 타입(`RefEquipment` …)에 칸이 있어도 매핑 함수가 안 옮기면 **원본이 채운 값이 문턱에서
+ * 사라진다.** 타입만 봐서는 안 보인다 — 타입은 「받는다」고 말하고 있으니까.
+ *
+ * 실제로 그렇게 났다: 설비 22대에 등급을 다 채웠는데 등급 목록만 서고 소속은 아무도 없었다.
+ * 화면에서 등급을 골라도 설비가 안 나왔고, 거절도 경고도 없었다.
+ *
+ * ── 왜 원문을 읽나 ──────────────────────────────────────────────────────────
+ * 매핑은 객체 리터럴이라 런타임에 「무엇을 옮기나」를 물을 수 없다(입력을 다 채워 넣어 답을 보는
+ * 방법이 있지만, 그러면 선택 필드마다 픽스처를 손으로 적어야 하고 그 손이 바로 빠뜨리는 자리다).
+ * 원문에서 읽으면 **이름을 손으로 적지 않아** 타입이 늘 때 검사가 함께 따라간다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+const SRC = readFileSync(new URL('../server/service/reference/reference-master.ts', import.meta.url), 'utf8')
+  .replace(/\/\*[\s\S]*?\*\//g, '')
+  .replace(/\/\/[^\n]*/g, '')
+
+/** 접수 타입 하나의 칸 이름들 — `export interface X { … }` 의 깊이 1 필드. */
+function intakeFields(name: string): string[] {
+  const start = SRC.indexOf(`export interface ${name} {`)
+  assert.ok(start >= 0, `접수 타입을 못 찾았다: ${name} — 이 검사가 따라가야 한다`)
+  const body = SRC.slice(SRC.indexOf('{', start))
+  const end = body.indexOf('\n}')
+  assert.ok(end > 0, `${name} 의 끝을 못 찾았다`)
+  return [...new Set([...body.slice(0, end).matchAll(/^\s{2}([a-zA-Z][\w]*)\??:/gm)].map(m => m[1]))]
+}
+
+/**
+ * 매핑 함수가 **읽는** 칸들 — `e.foo` · `a.foo` 처럼 원본 줄에서 꺼내는 이름.
+ *
+ * 옮긴 뒤 이름이 바뀌는 것도 있다(`homeLocationId → homeLocation`). 그래서 「나가는 이름」이 아니라
+ * **「읽는 이름」**을 센다 — 읽지 않으면 옮길 수도 없다.
+ */
+function readFields(varName: string): string[] {
+  return [...new Set([...SRC.matchAll(new RegExp(`\\b${varName}\\.([a-zA-Z][\\w]*)`, 'g'))].map(m => m[1]))]
+}
+
+/**
+ * 일부러 안 옮기는 칸 — 이유와 함께.
+ *
+ * 비어 있는 것이 정상이 아니다: 접수면이 받아 두고 커널에 안 넘기는 값이 있으면 **왜 받는지**가
+ * 적혀 있어야 한다. 안 적으면 다음 사람이 「원래 그런가 보다」로 넘긴다.
+ */
+const NOT_MAPPED: Record<string, { fields: string[]; why: string }> = {
+  RefEquipment: {
+    fields: [],
+    why: ''
+  },
+  RefAsset: {
+    fields: [],
+    why: ''
+  },
+  RefPerson: {
+    fields: [],
+    why: ''
+  }
+}
+
+const CASES = [
+  { intake: 'RefEquipment', reads: 'e' },
+  { intake: 'RefAsset', reads: 'a' },
+  { intake: 'RefPerson', reads: 'p' }
+] as const
+
+test('★ 접수 타입의 칸을 매핑이 다 읽는다 — 안 읽으면 원본이 채운 값이 문턱에서 사라진다', () => {
+  const dropped: string[] = []
+
+  for (const c of CASES) {
+    const excused = new Set(NOT_MAPPED[c.intake]?.fields ?? [])
+    const read = new Set(readFields(c.reads))
+
+    for (const f of intakeFields(c.intake)) {
+      if (!read.has(f) && !excused.has(f)) dropped.push(`${c.intake}.${f}`)
+    }
+  }
+
+  assert.deepEqual(
+    dropped,
+    [],
+    '접수 타입은 받는다고 말하는데 매핑이 안 읽는다. 원본이 채운 값이 조용히 사라진다:\n  ' +
+      dropped.join('\n  ') +
+      '\n매핑에 넣거나, 일부러 안 넘긴다면 NOT_MAPPED 에 이유를 적는다.'
+  )
+})
+
+test('★ 등급 소속 셋이 다 접수면을 지난다 — 이름으로 못 박는다', () => {
+  /*
+   * 위 검사는 목록 대조라 예외 표에 올리면 통과한다. 이 셋은 **소속이 없으면 등급으로 부르는
+   * 요구가 채워지지 않는** 자리여서 예외가 될 수 없다.
+   */
+  for (const [type, field, reads] of [
+    ['RefEquipment', 'equipmentClassIds', 'e'],
+    ['RefAsset', 'assetClassIds', 'a'],
+    ['RefPerson', 'personnelClassIds', 'p']
+  ] as const) {
+    assert.ok(intakeFields(type).includes(field), `${type} 에 ${field} 칸이 없다`)
+    assert.ok(readFields(reads).includes(field), `매핑이 ${type}.${field} 를 안 읽는다 — 소속이 문턱에서 사라진다`)
+  }
+})
+
+test('★ 사람도 정체성 자리를 갖는다 — 그리고 그 자리는 개인정보가 아니다', () => {
+  /*
+   * ── 왜 열었나 (2026-09-05, 인티그레이션 레인이 물음) ────────────────────────
+   * 설비에서 이 자리를 만든 이유가 사람에게도 그대로 걸린다 — 지역 이름은 그 현장 안에서만
+   * 고유하다. `E-1001` 이 다른 공장에도 있으면 여러 현장을 함께 보는 순간 한쪽이 사라진다.
+   *
+   * ── 왜 이 검사에 규약을 함께 적나 ──────────────────────────────────────────
+   * 설비와 사람이 갈리는 자리가 있다. 사람의 「전역에서 고유한 값」은 사원번호·카드번호처럼
+   * **그 사람에 관한 사실**이고, 저널은 되풀이 읽히고 미러로 복제되고 구독으로 방송된다 —
+   * 한 번 들어가면 지워지지 않는다.
+   *
+   * 이 칸이 요구하는 것은 **현장을 앞에 붙여 전역에서 고유해진 이름**이다(`objectUri` 가 만든다).
+   * 그 규약이 주석에만 있으면 다음 커넥터가 카드번호를 넣는다 — 그러니 소스에 그 문장이 실제로
+   * 있는지를 검사가 지킨다.
+   */
+  assert.ok(intakeFields('RefPerson').includes('identity'), 'RefPerson 에 identity 칸이 없다')
+  assert.ok(readFields('p').includes('identity'), '매핑이 사람의 identity 를 안 읽는다')
+
+  /* 규약이 글로 남아 있나 — 지우면 이 줄이 빨개진다. */
+  const raw = readFileSync(new URL('../server/service/reference/reference-master.ts', import.meta.url), 'utf8')
+  const start = raw.indexOf('export interface RefPerson')
+  const personDoc = raw.slice(start, raw.indexOf('\n}', start))
+  assert.ok(personDoc.includes('개인정보'), '개인정보를 넣지 않는다는 규약이 사라졌다')
+  assert.ok(personDoc.includes('objectUri'), '무엇을 넣어야 하는지(이름공간 아래 식별자)가 사라졌다')
+})
+
+test('★ 정체성 낱말이 세 자리에서 같다 — 마스터가 내는 이름과 접수면이 받는 이름', () => {
+  /*
+   * 설비는 `identity` 로 바꿨는데 자산은 `gs1Id` 로 남아 있었다. 마스터는 둘 다 `identity` 로
+   * 내므로 자산 쪽은 **원본이 채우는 순간 조용히 사라졌다** — 값이 다 비어 있어 아직 잃은 것은
+   * 없었다(인티그레이션 레인 실측).
+   *
+   * 자리(`RefLocation`)는 `gs1Id` 가 맞다 — 거기는 실제로 SGLN 이 온다.
+   */
+  assert.ok(intakeFields('RefEquipment').includes('identity'), '설비 정체성 이름이 바뀌었다')
+  assert.ok(intakeFields('RefAsset').includes('identity'), '자산이 아직 마스터와 다른 이름을 쓴다')
+  assert.ok(!intakeFields('RefAsset').includes('gs1Id'), '자산에 옛 이름이 남아 있다')
+  assert.ok(intakeFields('RefLocation').includes('gs1Id'), '자리는 SGLN 이 오므로 그 이름이 맞다')
+})
+
+test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
+  /*
+   * 정규식이 모양을 못 따라가면 목록이 비고, 그러면 위 검사가 **초록인데 아무것도 안 재는 상태**가
+   * 된다. 오늘 이 저장소에서 그 부류를 여러 번 잡았다.
+   */
+  for (const c of CASES) {
+    const fields = intakeFields(c.intake)
+    const read = readFields(c.reads)
+    assert.ok(fields.length > 5, `${c.intake} 칸을 ${fields.length}개만 읽었다`)
+    assert.ok(read.length > 5, `${c.reads}.* 를 ${read.length}개만 읽었다`)
+  }
+
+  /* 이유 없는 예외는 예외가 아니다 — 비어 있는 항목은 예외가 아니라 자리표시다. */
+  for (const [type, e] of Object.entries(NOT_MAPPED)) {
+    if (!e.fields.length) continue
+    assert.ok(e.why?.trim(), `${type} 의 예외에 이유가 없다`)
+  }
+})

package/test/live-cadence.test.ts

@@ -0,0 +1,170 @@
+/*
+ * ★ **원천마다 시간의 결이 다르다** — 밤마다 나던 거짓 빨강의 나머지 반쪽.
+ *
+ * 판정은 이미 두 값을 받을 수 있다(`syncVerdictOf` 의 `expectedSilenceMs`·`quietNow`). 없던 것은
+ * **원천이 그것을 말할 자리**였다. 인티그레이션 레인이 다섯을 재 왔다.
+ *
+ *   ppms 발전      일몰에 멈춘다 — 두 사이트가 같은 분 19:25 에 함께
+ *   ppms 계측      밤에도 온다 · 15분마다
+ *   ppms 가격      화·목만 거래된다 · 그 날 하루 한 번
+ *   plant         근무시간 창 · 훅이라 「보내면 온다」
+ *   chef          조업시간 창 · 같음
+ *
+ * 셋이 다 다르다 — 해에 매인 것, 사람 근무에 매인 것, 거래일에 매인 것. 그런데 **두 축으로
+ * 덮인다**: 「지금이 활동 시각인가」와 「그 안에서 얼마나 뜸한가」.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { cadenceOf, ingestExpectation, type LiveCadence } from '../server/service/reference/live-cadence.js'
+
+const NOW = 1_800_000_000_000
+
+/* ── 축을 찾는다 ──────────────────────────────────────────────────────────── */
+
+test('★ 선언한 축을 찾는다', () => {
+  const cadences: LiveCadence[] = [
+    { axis: 'equipment.status', windowKind: 'daylight' },
+    { axis: 'quality.output', expectedSilenceMs: 900_000 }
+  ]
+
+  assert.equal(cadenceOf(cadences, 'quality.output')?.expectedSilenceMs, 900_000)
+  assert.equal(cadenceOf(cadences, 'equipment.status')?.windowKind, 'daylight')
+})
+
+test('★ 선언하지 않은 축은 없다고 답한다 — 옛 거동으로 견주게', () => {
+  assert.equal(cadenceOf([{ axis: 'quality.output' }], 'order.status'), undefined)
+  assert.equal(cadenceOf(undefined, 'quality.output'), undefined)
+})
+
+/* ── 판정에 넘길 두 값으로 옮긴다 ───────────────────────────────────────── */
+
+test('★ 선언이 없으면 아무것도 답하지 않는다 — 「모른다」를 「안 와도 된다」로 접지 않는다', () => {
+  /*
+   * 여기서 `quietNow: true` 를 내면 **선언 안 한 원천이 전부 조용해진다.** 정말 끊긴 것도
+   * 조용해지고, 그러면 이 축을 만든 목적을 잃는다.
+   */
+  assert.deepEqual(ingestExpectation(undefined, { nowMs: NOW }), {})
+})
+
+test('★ 15분마다 긷는 원천 — 주기만 넘긴다', () => {
+  const out = ingestExpectation({ axis: 'quality.output', expectedSilenceMs: 900_000 }, { nowMs: NOW })
+
+  assert.equal(out.expectedSilenceMs, 900_000)
+  assert.equal(out.quietNow, undefined, '창을 선언하지 않았는데 시각을 단언했다')
+})
+
+test('0이나 음수 주기는 선언이 아니다', () => {
+  for (const bad of [0, -1, NaN]) {
+    const out = ingestExpectation({ axis: 'a', expectedSilenceMs: bad }, { nowMs: NOW })
+    assert.equal(out.expectedSilenceMs, undefined, `${bad} 를 주기로 받았다`)
+  }
+})
+
+/* ── 「보내면 온다」 ──────────────────────────────────────────────────────── */
+
+test('★ 훅으로 미는 축은 침묵으로 판정하지 않는다 — plant 가 그렇다', () => {
+  /*
+   * 보낼 것이 없으면 안 보내는 것이 정상이다. 「주기가 없다」와 「모른다」를 가르는 값이다.
+   */
+  const out = ingestExpectation({ axis: 'order.status', pushed: true }, { nowMs: NOW })
+
+  assert.equal(out.quietNow, true)
+})
+
+test('★ 미는 축은 창 판정을 기다리지 않는다 — 판정 수단이 없어도 답한다', () => {
+  const out = ingestExpectation(
+    { axis: 'order.status', pushed: true, window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
+    { nowMs: NOW } /* inWindow 를 주지 않았다 */
+  )
+
+  assert.equal(out.quietNow, true)
+})
+
+/* ── 창 ──────────────────────────────────────────────────────────────────── */
+
+test('★ 활동 시각 안이면 조용할 때가 아니다', () => {
+  const out = ingestExpectation(
+    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
+    { nowMs: NOW, inWindow: () => true }
+  )
+
+  assert.equal(out.quietNow, false)
+})
+
+test('★ 활동 시각 밖이면 조용할 때다', () => {
+  const out = ingestExpectation(
+    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
+    { nowMs: NOW, inWindow: () => false }
+  )
+
+  assert.equal(out.quietNow, true)
+})
+
+test('★ 판정 수단을 안 받았으면 시각을 단언하지 않는다 — 지어낸 값을 만들지 않는다', () => {
+  /*
+   * 부르는 쪽이 달력 판정 함수를 주지 않았는데 우리가 「활동 시각이다」로 답하면, 창을 선언한
+   * 원천이 **창이 없는 것과 같아진다.** 그것은 조용한 실패다.
+   */
+  const out = ingestExpectation(
+    { axis: 'quality.output', window: [{ id: 'day', entryType: 'production', startTime: '09:00', endTime: '18:00' }] },
+    { nowMs: NOW }
+  )
+
+  assert.equal(out.quietNow, undefined)
+})
+
+test('빈 창은 창이 아니다', () => {
+  assert.equal(ingestExpectation({ axis: 'a', window: [] }, { nowMs: NOW, inWindow: () => false }).quietNow, undefined)
+})
+
+/* ── 두 축이 함께 온다 ──────────────────────────────────────────────────── */
+
+test('★ 주기와 창을 같이 선언할 수 있다 — 인증서 가격이 그 모양이다', () => {
+  /*
+   * 화·목만 거래되고 그 날 하루 한 번 온다. 「매일 와야 한다」로 재면 주 5일 중 3일이 빨갛고,
+   * 「주 2회」로 재면 이어 쓴 날을 못 본다. 두 축이면 둘 다 답한다.
+   */
+  const out = ingestExpectation(
+    {
+      axis: 'quality.output',
+      expectedSilenceMs: 26 * 3_600_000,
+      window: [
+        { id: 'tue', entryType: 'production', startTime: '00:00', endTime: '23:59' },
+        { id: 'thu', entryType: 'production', startTime: '00:00', endTime: '23:59' }
+      ]
+    },
+    { nowMs: NOW, inWindow: () => false }
+  )
+
+  assert.equal(out.expectedSilenceMs, 26 * 3_600_000)
+  assert.equal(out.quietNow, true, '거래일이 아니면 조용한 것이 정상이다')
+})
+
+/* ── 「해 있는 동안」은 호스트가 채운다 ──────────────────────────────────── */
+
+test('★ 종류만 선언한 것으로는 창 판정을 하지 않는다 — 호스트가 채워야 한다', () => {
+  /*
+   * 커널은 일출·일몰을 계산하지 않는다(굴절·고위도·박명 정의가 다 선택이고, 정하면 방언이다).
+   * 원천은 종류만 말하고, 좌표를 아는 호스트가 날마다 구체적인 구간을 채운다.
+   *
+   * 그러니 `windowKind` 만 있고 `window` 가 비어 있으면 **아직 채워지지 않은 것**이고, 그때
+   * 판정하지 않는다. `false` 로 접으면 태양광이 밤에도 활동 시각인 것이 된다.
+   */
+  const out = ingestExpectation({ axis: 'equipment.status', windowKind: 'daylight' }, { nowMs: NOW, inWindow: () => true })
+
+  assert.equal(out.quietNow, undefined)
+})
+
+test('★ 호스트가 채우면 그것으로 판정한다', () => {
+  const out = ingestExpectation(
+    {
+      axis: 'equipment.status',
+      windowKind: 'daylight',
+      window: [{ id: 'today', entryType: 'production', startTime: '06:12', endTime: '19:25' }]
+    },
+    { nowMs: NOW, inWindow: () => false }
+  )
+
+  assert.equal(out.quietNow, true)
+})

package/test/live-feed-lease.test.ts

@@ -0,0 +1,63 @@
+/*
+ * The name a live feed takes its lease under.
+ *
+ * This is worth a test because the failure it prevents is silent: two feeds
+ * sharing one name means one of them stops, and it stops looking like
+ * "someone else holds it" — the ordinary case on every instance but one, so
+ * nothing gets logged and nothing looks wrong.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { liveFeedLeaseName } from '../server/service/reference/live-feed-lease.js'
+
+test('the domain is part of the name, so two tenants do not block each other', () => {
+  /*
+   * This is the whole reason the reference layer composes the name instead of
+   * the adapter: an adapter is handed cfg and site, and neither carries a
+   * domain, so a name built there would collide across tenants.
+   */
+  const a = liveFeedLeaseName('domain-a', 'mes-line-a', 'mes')
+  const b = liveFeedLeaseName('domain-b', 'mes-line-a', 'mes')
+
+  assert.notEqual(a, b)
+  assert.ok(a.includes('domain-a'))
+})
+
+test('the instance is part of the name, so two twins on one source do not block each other', () => {
+  const a = liveFeedLeaseName('d', 'mes-line-a', 'mes')
+  const b = liveFeedLeaseName('d', 'mes-miratek', 'mes')
+
+  assert.notEqual(a, b)
+})
+
+test('the same feed always gets the same name, so a second instance sees it as taken', () => {
+  assert.equal(liveFeedLeaseName('d', 'i', 's'), liveFeedLeaseName('d', 'i', 's'))
+})
+
+test('the name says it is a live feed, so a lease table read tells you the kind of task', () => {
+  assert.ok(liveFeedLeaseName('d', 'i', 's').startsWith('twin-live::'))
+})
+
+test('a missing source still names the feed — an instance has one feed', () => {
+  const named = liveFeedLeaseName('d', 'i')
+
+  assert.equal(named, 'twin-live::d::i')
+  assert.notEqual(named, liveFeedLeaseName('d', 'other'))
+})
+
+test('a blank source is the same as none rather than an empty segment', () => {
+  assert.equal(liveFeedLeaseName('d', 'i', '   '), liveFeedLeaseName('d', 'i'))
+})
+
+test('a missing domain or instance is refused, not filled in', () => {
+  /*
+   * Composing a name from a blank would put two feeds on one row. Throwing
+   * here surfaces it at startup; filling it in would surface it as a channel
+   * that quietly stopped weeks later.
+   */
+  assert.throws(() => liveFeedLeaseName('', 'i', 's'), /domainId/)
+  assert.throws(() => liveFeedLeaseName('   ', 'i', 's'), /domainId/)
+  assert.throws(() => liveFeedLeaseName('d', '', 's'), /instanceId/)
+  assert.throws(() => liveFeedLeaseName('d', undefined as any, 's'), /instanceId/)
+})

package/test/live-mirror-parity.test.ts

@@ -213,7 +213,7 @@ test('★ OEE derive: 공유 공식 computeOee 가 공급된 카운터로 OEE
    */
   const planned = o.runMs + o.setupMs + o.downMs + o.delayMs
   const derived = computeOee(
-    { runMs: o.runMs, setupMs: o.setupMs, downMs: o.downMs, goodCount: o.goodCount, scrapCount: o.scrapCount, metricsSinceMs: 0 },
+    { runMs: o.runMs, setupMs: o.setupMs, downMs: o.downMs, goodCount: o.goodCount, nonconformingCount: o.nonconformingCount, metricsSinceMs: 0 },
     planned
   )
   /* 세 비율은 근거가 없으면 없다 — 양쪽 다 없는 것도 재생산이다(계약 0.5.0). */

package/test/oee-accumulator.test.ts

@@ -90,13 +90,13 @@ test('★ OEE 누적기: quality.output 델타 소비 → quality 정확 (good/s
   const ev = (ms: number, type: string, data: any): any => ({ eventId: 'x', eventType: type, eventTime: new Date(T0 + ms).toISOString(), tenantId: 't', data })
 
   acc.apply(ev(0, 'equipment.status', { moverId: 'w1', status: 'busy' }))
-  acc.apply(ev(1000, 'quality.output', { moverId: 'w1', good: false, goodCount: 0, scrapCount: 1 }))
-  acc.apply(ev(2000, 'quality.output', { moverId: 'w1', good: true, goodCount: 8, scrapCount: 2 })) // 누적값 최신화
+  acc.apply(ev(1000, 'quality.output', { moverId: 'w1', good: false, goodCount: 0, nonconformingCount: 1 }))
+  acc.apply(ev(2000, 'quality.output', { moverId: 'w1', good: true, goodCount: 8, nonconformingCount: 2 })) // 누적값 최신화
   acc.apply(ev(3000, 'equipment.status', { moverId: 'w1', status: 'idle' }))
 
   const c = acc.counters('w1', T0 + 4000)
   assert.equal(c.goodCount, 8, 'goodCount 추적(누적 최신)')
-  assert.equal(c.scrapCount, 2, 'scrapCount 추적')
+  assert.equal(c.nonconformingCount, 2, 'nonconformingCount 추적')
   const oee = acc.oee('w1', T0 + 4000)
   assert.ok(Math.abs(oee.quality - 0.8) < 1e-9, 'quality = good/(good+scrap) = 0.8 (텔레메트리 없이 이벤트로 도출)')
 })

package/test/oee-site-calendar.test.ts

@@ -0,0 +1,146 @@
+/*
+ * 현장의 조업 달력이 계획 조업 시간에 닿나.
+ *
+ * ── 왜 필요한가 (2026-09-07) ────────────────────────────────────────────────
+ * 계획 조업 시간(PBT)이 「재기 시작한 뒤 흐른 시간 전부」였다. 주말도 야간도 휴일도 계획 조업으로
+ * 세었다. [산술] 8시간 × 주5일이면 168시간 중 40시간이 조업이니 PBT 가 4.2배 크다.
+ *
+ * plant 레인이 같은 자리를 먼저 겪고 실측을 냈다 — 3교대를 물려받으면 `availability 0.4583`,
+ * 달력이 아예 없으면 수를 안 낸다. 트윈은 창 전체를 계획으로 쳐서 수를 냈다.
+ *
+ * ── 이 시험이 지키는 것은 「자리가 있고 부르는 곳이 있다」다 ─────────────────
+ * 오늘 이 저장소에서 그것을 여섯 번 놓쳤다. 값을 받을 칸을 만들고 아무도 채우지 않거나, 채우고
+ * 아무도 안 읽는 자리다. 그래서 여기서는 **누적기가 그 값을 실제로 쓰는지**를 본다 — 달력을 얹은
+ * 것과 안 얹은 것의 답이 달라야 한다.
+ */
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import { OeeAccumulator } from '../server/engine/oee-accumulator.js'
+
+const HOUR = 3_600_000
+const MON = Date.UTC(2026, 8, 7, 0, 0, 0)
+
+/** 08:00~16:00 만 조업 — 하루 열여섯 시간이 비근무다. */
+const EIGHT_HOURS = [{ id: 'day', fromTime: '08:00', toTime: '16:00' }] as any[]
+
+/** 여덟 시간 내내 돈 설비 한 대. */
+function ranAllShift(calendar?: any[]) {
+  const acc = new OeeAccumulator()
+  acc.setWorkCalendar(calendar ? { workCalendar: calendar } : undefined)
+  /*
+   * 봉투의 `data` 에 `moverId` 다 — `payload.data` 도 `equipmentId` 도 아니다. 처음 그렇게 써서
+   * 누적기가 아무것도 안 받았고, 시험 넷이 빨개져서 알았다. 읽어서 고쳤다(`oee-accumulator.ts:111`).
+   */
+  acc.apply({
+    eventType: 'equipment.status',
+    eventTime: new Date(MON + 8 * HOUR).toISOString(),
+    data: { moverId: 'EQ-1', status: 'busy' }
+  } as any)
+
+  return acc.counters('EQ-1', MON + 24 * HOUR)
+}
+
+test('달력을 얹으면 계획 정지가 나온다 — 계측 창 안의 비근무만', () => {
+  /*
+   * ⚠ 하루가 아니다. 계측 창은 **첫 이벤트부터**이므로 08:00~24:00 의 열여섯 시간이고, 그중 조업이
+   * 08:00~16:00 이니 비근무가 여덟 시간이다.
+   *
+   * 처음 이 값을 열여섯으로 적었다 — 「하루 중 열여섯 시간이 비근무」라는 달력의 성질을 계측 창에
+   * 그대로 옮긴 것이다. 재보고 고쳤다. 계획 정지는 **달력의 성질이 아니라 이 창에서 잰 값**이다.
+   */
+  const c = ranAllShift(EIGHT_HOURS) as any
+
+  assert.equal(c.holdMs, 8 * HOUR)
+  assert.equal(c.metricsSinceMs, MON + 8 * HOUR, '창이 첫 이벤트부터라는 것이 위 계산의 전제다')
+})
+
+test('달력이 없으면 그 칸을 만들지 않는다 — 0 은 「쉬는 시간이 없다」는 주장이다', () => {
+  const c = ranAllShift() as any
+
+  assert.equal('holdMs' in c, false)
+})
+
+test('얹은 것과 안 얹은 것의 답이 다르다 — 같으면 그 값이 안 쓰이는 것이다', () => {
+  /*
+   * 이 시험이 이 파일의 요점이다. 오늘 제가 낸 결함 중 하나가 「값을 넣어 줄 사람이 있는지 아무것도
+   * 검사하지 않은 시험」이었다 — 고쳐도 통과하고 안 고쳐도 통과했다.
+   */
+  const withCal = ranAllShift(EIGHT_HOURS) as any
+  const without = ranAllShift() as any
+
+  assert.notEqual(withCal.holdMs, without.holdMs)
+})
+
+test('실 생산 시간은 달력과 무관하다 — APT 는 잰 값이다', () => {
+  /*
+   * 달력은 PBT 를 정하고 APT 는 안 건드린다. 휴일에 돌린 열한 시간이 사라지던 것이 그 반대 방향의
+   * 결함이었고, 그것은 자르는 쪽이었다.
+   */
+  const withCal = ranAllShift(EIGHT_HOURS)
+  const without = ranAllShift()
+
+  assert.equal(withCal.runMs, without.runMs)
+  assert.equal(withCal.runMs, 16 * HOUR, '08:00 에 busy 로 들어가 24:00 까지면 열여섯 시간이다')
+})
+
+test('잰 구간의 시작은 그대로다 — 그 칸에 파생값을 얹지 않는다', () => {
+  /*
+   * 같은 효과를 `metricsSinceMs` 를 당겨서 낼 수도 있는데, 그 칸은 「언제부터 쟀나」라는 사실이다.
+   * plant 레인이 그 방식으로 하고 있었고 `holdMs` 로 옮겼다 — 수는 자릿수까지 같았다.
+   */
+  const c = ranAllShift(EIGHT_HOURS)
+
+  assert.equal(c.metricsSinceMs, MON + 8 * HOUR)
+})
+
+/*
+ * ── 설비의 달력이 현장의 것을 이긴다 ────────────────────────────────────────
+ * 이 자리가 실제 자료를 살렸다. rosarito 트윈들이 설비 41대에 3교대 × 평일 달력을 이미 갖고 있었는데,
+ * 처음 배선할 때 **현장 달력만 읽었다.** 현장에 달력을 선언한 공간이 하나도 없어서, 있는 자료를 두고
+ * 계획 조업 시간이 창 전체로 남아 있었다.
+ *
+ * 사용자가 「모든 공간에 달력을 세우라」고 한 것이 그 말을 듣고 나온 지시였고, 재보니 세울 것이 아니라
+ * **읽을 것이 있었다.**
+ */
+const ROUND_CLOCK = [{ id: 'always', fromTime: '00:00', toTime: '24:00' }] as any[]
+
+function withModel(model: any) {
+  const acc = new OeeAccumulator()
+  acc.setWorkCalendar(model)
+  acc.apply({
+    eventType: 'equipment.status',
+    eventTime: new Date(MON + 8 * HOUR).toISOString(),
+    data: { moverId: 'EQ-1', status: 'busy' }
+  } as any)
+
+  return acc.counters('EQ-1', MON + 24 * HOUR) as any
+}
+
+test('설비가 자기 달력을 선언하면 그것을 쓴다 — 24시간 도는 로가 현장 근무조에 안 잘린다', () => {
+  const c = withModel({ workCalendar: EIGHT_HOURS, equipment: [{ id: 'EQ-1', workCalendar: ROUND_CLOCK }] })
+
+  assert.equal(c.holdMs, 0, '자기 달력이 종일 가동이면 계획 정지가 없다')
+})
+
+test('설비가 선언하지 않으면 현장의 달력으로 떨어진다', () => {
+  const c = withModel({ workCalendar: EIGHT_HOURS, equipment: [{ id: 'EQ-OTHER', workCalendar: ROUND_CLOCK }] })
+
+  assert.equal(c.holdMs, 8 * HOUR, '이 설비의 것이 없으니 현장 것을 쓴다')
+})
+
+test('현장이 없고 설비만 있어도 답한다 — 지금 실제 자료가 그 모양이다', () => {
+  /*
+   * rosarito 가 이렇다: 공간에 달력이 없고 설비 41대에 3교대가 있다. 현장 달력만 읽으면 이 자료가
+   * 통째로 안 쓰인다.
+   */
+  const c = withModel({ equipment: [{ id: 'EQ-1', workCalendar: EIGHT_HOURS }] })
+
+  assert.equal(c.holdMs, 8 * HOUR)
+})
+
+test('둘 다 없으면 그 칸을 만들지 않는다', () => {
+  const c = withModel({ equipment: [{ id: 'EQ-1' }] })
+
+  assert.equal('holdMs' in c, false)
+})