@things-factory/headless-twin 10.1.278 → 10.1.279

package/test/dispatch-after-approval-source.test.ts

@@ -1,81 +0,0 @@
-/*
- * Two properties of the dispatch that follows an approval, guarded by reading its source.
- *
- * ── Why source and not behaviour ───────────────────────────────────────────
- * `dispatchAfterApproval` runs outside the request, touches the database and reaches an
- * adapter that talks to a factory. It cannot be exercised here. What can be guarded is the
- * shape of the two decisions that make it safe, and both are visible in the text.
- *
- * ── Why the guard lives here now (2026-09-08) ──────────────────────────────
- * These two assertions were in `operato-twin/test/actuation-gate-walk.test.ts`, reading
- * `../../headless-twin/server/…`. The applications then moved to the operato-application
- * repository and that relative path left this repository — three checks failed with ENOENT.
- *
- * The subject of both is a file in *this* package, so this is where they belong. The half that
- * guards the app's own callback (that approval, and only approval, calls dispatch) stays with
- * the app. A guard reads its own repository; when it has to read across one, the seam is in
- * the wrong place.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { guardFile } from './guard-roots.js'
-
-const PLACE = '../server/service/actuation/dispatch-after-approval.ts'
-
-/** The source with comments removed — a term inside a comment is not a use of it. */
-function sourceOf(): string {
-  return readFileSync(guardFile(import.meta.url, PLACE), 'utf8')
-}
-
-function withoutComments(src: string): string {
-  return src.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '')
-}
-
-test('dispatch does not run inside the approval transaction', () => {
-  /*
-   * Approval happens inside the worklist's transaction. Sending a request to the factory from
-   * inside it means a rollback cannot take the request back: the plant keeps the work order
-   * and our ledger has the approval undone. What went out over the network was never in the
-   * transaction's care.
-   *
-   * A transaction-bound store is passed the transaction — `databaseCommandStore(tx)`. An
-   * unbound one takes no argument. So the argument list is the property.
-   */
-  const src = withoutComments(sourceOf())
-
-  assert.match(src, /databaseCommandStore\(\)/, 'dispatch uses a transaction-bound store')
-  assert.doesNotMatch(src, /databaseCommandStore\(\s*[a-zA-Z]/, 'dispatch is being handed a transaction store')
-})
-
-test('a failed dispatch does not undo the approval, and does not take the process down', () => {
-  /*
-   * This runs outside the request, in `setImmediate`. A throw there is an unhandled rejection
-   * and the server exits — one undelivered actuation would stop everything else.
-   *
-   * The approval also has to survive an adapter that is down. That is the whole reason
-   * approving and dispatching are two steps, and it is a measured property, not a wish:
-   * command `67f8765a` was dispatched successfully later, on the same approval.
-   */
-  const src = sourceOf()
-
-  assert.match(src, /catch\s*\(/, 'nothing catches a failed dispatch')
-  assert.doesNotMatch(
-    withoutComments(src),
-    /\bthrow\b/,
-    'the dispatch path throws — outside a request that ends the process'
-  )
-})
-
-test('this guard reads the real file, so a wrong path is red and not green', () => {
-  /*
-   * The two checks above fail when a pattern stops matching. They would also "pass" against an
-   * empty string, so the path itself has to be guarded — that is exactly how these assertions
-   * left this repository unnoticed in the first place.
-   */
-  const src = sourceOf()
-
-  assert.ok(src.length > 1000, `the dispatch source is ${src.length} chars — the path is wrong`)
-  assert.match(src, /dispatchAfterApproval/, 'the file read is not the one this guard names')
-})

package/test/duration-estimators.test.ts

@@ -1,144 +0,0 @@
-/*
- * 소요시간 추정기 — **상수를 데이터로 바꾸는 두 층(실측 · 거리×속도).**
- *
- * 커널 `durationOf` 의 우선순위는 추정기 > 명세 > 상수다. 그 추정기 자리에 호스트가 넣는 두 가지를
- * 여기서 고정한다. 핵심 규율은 하나다 — **모르면 답하지 않는다**(undefined → 커널이 명세·상수로).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { EQUIPMENT_PROPERTY, buildTravelEstimator, chainEstimators } from '../server/engine/travel-estimator.ts'
-import { DEFAULT_MIN_SAMPLES, buildMeasuredEstimator } from '../server/engine/measured-estimator.ts'
-
-const layout = { dock: { x: 0, y: 0 }, rack: { x: 30, y: 40 } } // 거리 50m
-const equipment = (uom?: string, value = '2') => [
-  { id: 'fk-1', kind: 'forklift', properties: [{ id: EQUIPMENT_PROPERTY.speed, value, ...(uom ? { uom } : {}) }] }
-]
-
-/* ── 거리 × 속도 ────────────────────────────────────────────────────────── */
-
-test('거리와 속도가 있으면 이동시간을 계산한다 — 상수 30초가 아니라 50m/2(m/s)=25초', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout, equipment: equipment('MTS'), unit: 'm' })
-  assert.deepEqual(reasons, [])
-  assert.equal(estimator!.estimate({ kind: 'putaway', fromNode: 'dock', toNode: 'rack', resourceKind: 'forklift' }), 25_000)
-})
-
-test('단위 코드를 표준대로 환산한다 — KMH 는 m/s 가 아니다', () => {
-  const { estimator } = buildTravelEstimator({ layout, equipment: equipment('KMH', '7.2'), unit: 'm' })
-  // 7.2 km/h = 2 m/s → 50m = 25초
-  assert.equal(estimator!.estimate({ kind: 'putaway', fromNode: 'dock', toNode: 'rack', resourceKind: 'forklift' }), 25_000)
-})
-
-test('단위 없는 속도는 m/s 라고 가정하지 않는다 — 3 이 초속 3m 인지 시속 3km 인지 뜻이 다르다', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout, equipment: equipment(undefined), unit: 'm' })
-  assert.equal(estimator, undefined)
-  assert.ok(reasons.some(r => r.includes('unit of measure')))
-})
-
-test('모르는 단위 코드는 받지 않는다', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout, equipment: equipment('WAT'), unit: 'm' })
-  assert.equal(estimator, undefined)
-  assert.ok(reasons.some(r => r.includes('unknown speed unit')))
-})
-
-test('좌표가 없으면 만들지 않고 이유를 남긴다', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout: {}, equipment: equipment('MTS'), unit: 'm' })
-  assert.equal(estimator, undefined)
-  assert.ok(reasons.some(r => r.includes('no location coordinates')))
-})
-
-test('속도를 아무도 선언하지 않으면 거리만으로 시간을 만들지 않는다', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout, equipment: [{ id: 'fk-1', kind: 'forklift' }], unit: 'm' })
-  assert.equal(estimator, undefined)
-  assert.ok(reasons.some(r => r.includes('speed')))
-})
-
-test('좌표 단위가 미터가 아니면 환산을 추측하지 않는다', () => {
-  const { estimator, reasons } = buildTravelEstimator({ layout, equipment: equipment('MTS'), unit: 'ft' })
-  assert.equal(estimator, undefined)
-  assert.ok(reasons.some(r => r.includes('not metres')))
-})
-
-test('같은 자리의 작업(처리·체류)은 다루지 않는다 — 거리 0 을 0 초로 만들면 공정 시간이 사라진다', () => {
-  const { estimator } = buildTravelEstimator({ layout, equipment: equipment('MTS'), unit: 'm' })
-  assert.equal(estimator!.estimate({ kind: 'cut', fromNode: 'rack', toNode: 'rack', resourceKind: 'forklift' }), undefined)
-})
-
-test('좌표 모르는 노드·속도 모르는 자원종류는 넘긴다(부분 적용)', () => {
-  const { estimator } = buildTravelEstimator({ layout, equipment: equipment('MTS'), unit: 'm' })
-  assert.equal(estimator!.estimate({ kind: 'putaway', fromNode: 'dock', toNode: 'rack-99', resourceKind: 'forklift' }), undefined)
-  assert.equal(estimator!.estimate({ kind: 'spot', fromNode: 'dock', toNode: 'rack', resourceKind: 'hostler' }), undefined)
-  assert.equal(estimator!.estimate({ kind: 'spot', fromNode: 'dock', toNode: 'rack' }), undefined, '자원 종류 미지')
-})
-
-/* ── 실측(이력) ─────────────────────────────────────────────────────────── */
-
-test('작업 종류별 작업시간 p50 을 소요로 배운다 — 리드타임(대기 포함)이 아니라 작업시간', () => {
-  const r = buildMeasuredEstimator([
-    { key: 'putaway', workTime: { count: 40, p50Ms: 47_000 } },
-    { key: 'pick', workTime: { count: 12, p50Ms: 22_500 } }
-  ])
-  assert.deepEqual(r.learned, { putaway: 47_000, pick: 22_500 })
-  assert.deepEqual(r.estimator!.estimate({ kind: 'putaway', fromNode: 'a', toNode: 'b' }), { meanMs: 47_000 })
-  assert.equal(r.estimator!.estimate({ kind: 'unseen', fromNode: 'a', toNode: 'b' }), undefined, '못 배운 종류는 넘긴다')
-})
-
-/* ── 관측된 퍼짐 ────────────────────────────────────────────────────────── */
-
-test('두 꼬리가 있으면 퍼짐까지 배운다 — 평균만 배우면 줄이 생기지 않는다', () => {
-  const r = buildMeasuredEstimator([{ key: 'putaway', workTime: { count: 40, p10Ms: 30_000, p50Ms: 47_000, p90Ms: 80_000 } }])
-  assert.deepEqual(r.spreads, { putaway: { minMs: 30_000, maxMs: 80_000 } })
-  assert.deepEqual(r.estimator!.estimate({ kind: 'putaway', fromNode: 'a', toNode: 'b' }), {
-    meanMs: 47_000,
-    spread: { distribution: 'triangular', minMs: 30_000, maxMs: 80_000, modeMs: 47_000 }
-  })
-})
-
-test('한쪽 꼬리만 있으면 퍼짐을 만들지 않는다 — 아래쪽을 위쪽에서 베끼는 것은 발명이다', () => {
-  const r = buildMeasuredEstimator([{ key: 'pick', workTime: { count: 40, p50Ms: 20_000, p90Ms: 40_000 } }])
-  assert.deepEqual(r.spreads, {})
-  assert.deepEqual(r.estimator!.estimate({ kind: 'pick', fromNode: 'a', toNode: 'b' }), { meanMs: 20_000 })
-})
-
-test('구간이 성립하지 않으면 퍼짐 없이 평균만 — 없는 흔들림을 만들지 않는다', () => {
-  const r = buildMeasuredEstimator([{ key: 'pick', workTime: { count: 40, p10Ms: 50_000, p50Ms: 20_000, p90Ms: 20_000 } }])
-  assert.deepEqual(r.spreads, {}, 'p10 >= p90 이면 구간이 아니다')
-})
-
-test('표본이 적으면 배우지 않고, 무엇을 버렸는지 밝힌다 — 두 건의 p50 은 현장 값이 아니다', () => {
-  const r = buildMeasuredEstimator([{ key: 'pick', workTime: { count: 2, p50Ms: 9_000 } }])
-  assert.equal(r.estimator, undefined)
-  assert.deepEqual(r.skipped, [{ kind: 'pick', count: 2 }])
-  assert.equal(r.minSamples, DEFAULT_MIN_SAMPLES)
-})
-
-test("'unknown' 축은 배우지 않는다 — 종류 모르는 기록을 특정 종류의 근거로 쓰지 않는다", () => {
-  const r = buildMeasuredEstimator([{ key: 'unknown', workTime: { count: 99, p50Ms: 30_000 } }])
-  assert.deepEqual(r.learned, {})
-  assert.equal(r.estimator, undefined)
-})
-
-test('p50 이 0 이면 쓰지 않는다 — 0 초 작업은 측정 실패다', () => {
-  const r = buildMeasuredEstimator([{ key: 'pick', workTime: { count: 50, p50Ms: 0 } }])
-  assert.deepEqual(r.learned, {})
-})
-
-test('그룹이 없으면 빈 결과 — 오류를 내지 않는다', () => {
-  assert.equal(buildMeasuredEstimator(undefined).estimator, undefined)
-  assert.equal(buildMeasuredEstimator([]).estimator, undefined)
-})
-
-/* ── 사슬 — 실측이 계산을 이긴다 ────────────────────────────────────────── */
-
-test('실측이 먼저, 없으면 거리 계산 — 강한 근거가 앞이다', () => {
-  const measured = buildMeasuredEstimator([{ key: 'pick', workTime: { count: 30, p50Ms: 11_000 } }])
-  const travel = buildTravelEstimator({ layout, equipment: equipment('MTS'), unit: 'm' })
-  const chained = chainEstimators([measured.estimator, travel.estimator])!
-  assert.deepEqual(chained.estimate({ kind: 'pick', fromNode: 'dock', toNode: 'rack', resourceKind: 'forklift' }), { meanMs: 11_000 }, '실측 우선')
-  assert.equal(chained.estimate({ kind: 'putaway', fromNode: 'dock', toNode: 'rack', resourceKind: 'forklift' }), 25_000, '실측 없으면 거리')
-  assert.equal(chained.estimate({ kind: 'putaway', fromNode: 'dock', toNode: 'dock', resourceKind: 'forklift' }), undefined, '둘 다 모르면 넘긴다')
-})
-
-test('빈 사슬은 undefined — 주입하지 않는다(상수로 굴러가는 것이 정직하다)', () => {
-  assert.equal(chainEstimators([undefined, undefined]), undefined)
-})

package/test/energy-topology.test.ts

@@ -1,113 +0,0 @@
-/*
- * 전력 계통도 — **선언된 것만 그린다.**
- *
- * 이 시험이 지키는 것: 계층·소속이 그림에 그대로 남고, 모르는 것(자리 없는 설비·계량 없는 구간·결선
- * 미상 부하)이 **각자 자기 칸으로** 나온다. 그림에서 사라지면 사용자는 자기 현장이 다 그려졌다고 믿는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { buildEnergyTopology } from '../server/engine/energy-topology.ts'
-
-const plant = () => ({
-  locations: [
-    { id: 'a-plant', type: 'plant', name: '공장' }, // 공간 부모 — 계통 축이 아니다
-    { id: 'incoming-1', type: 'incoming', name: '수전', parentId: 'a-plant' },
-    { id: 'feeder-press', type: 'feeder', name: 'Press line', parentId: 'incoming-1' },
-    { id: 'feeder-weld', type: 'feeder', name: 'Weld line', parentId: 'incoming-1' },
-    { id: 'zone-1', type: 'submeter-zone', name: '도장 구역', parentId: 'feeder-weld' }
-  ],
-  equipment: [
-    { id: 'meter-incoming', kind: 'meter', homeLocation: 'incoming-1' },
-    { id: 'meter-press', kind: 'meter', homeLocation: 'feeder-press' },
-    { id: 'breaker-1', kind: 'breaker', homeLocation: 'feeder-press' },
-    { id: 'ess-1', kind: 'battery', homeLocation: 'incoming-1' },
-    { id: 'press-1', kind: 'curtailable-load', homeLocation: 'feeder-press' },
-    { id: 'load-hvac', kind: 'curtailable-load', homeLocation: 'incoming-1' }, // 결선 미상
-    { id: 'ghost', kind: 'curtailable-load', homeLocation: 'nowhere' }
-  ]
-})
-
-test('계통 계층만 잇는다 — 공간 부모(공장)는 이 축이 아니다', () => {
-  const t = buildEnergyTopology(plant())
-  assert.equal(t.roots.length, 1)
-  assert.equal(t.roots[0].id, 'incoming-1', '수전이 뿌리다(공장 아래에 있어도)')
-  assert.deepEqual(t.roots[0].children.map(c => c.id), ['feeder-press', 'feeder-weld'])
-  assert.deepEqual(t.roots[0].children[1].children.map(c => c.id), ['zone-1'], '구역은 그 분기 아래')
-})
-
-test('계량기는 「이 구간을 잰다」로, 계통 설비는 따로, 부하는 부하로 — 섞지 않는다', () => {
-  const t = buildEnergyTopology(plant())
-  const press = t.roots[0].children[0]
-  assert.deepEqual(press.meters, ['meter-press'])
-  assert.deepEqual(press.gear.map(g => g.kind), ['breaker'])
-  assert.deepEqual(press.loads.map(l => l.id), ['press-1'])
-  assert.deepEqual(t.roots[0].gear.map(g => g.kind), ['battery'], '축전지는 부하가 아니다')
-})
-
-test('자리를 모르는 설비를 그림에서 지우지 않는다', () => {
-  const t = buildEnergyTopology(plant())
-  assert.deepEqual(t.unplaced.map(u => u.id), ['ghost'])
-})
-
-test('계량 없는 구간과 결선 미상 부하를 센다 — 「어디에 더 달아야 하나」의 답', () => {
-  const t = buildEnergyTopology(plant())
-  assert.deepEqual(t.unmetered.sort(), ['feeder-weld', 'zone-1'])
-  assert.equal(t.loadsOnIncoming, 1, '수전에 직결된 부하 — 어느 분기가 주는지 모르는 것들')
-})
-
-test('폴드가 낸 몫을 노드에 얹는다 — 값을 다시 계산하지 않는다', () => {
-  const t = buildEnergyTopology(plant(), {
-    byFeeder: [
-      { key: 'feeder-press', kWh: 124, basis: 'measured' },
-      { key: 'feeder-weld', kWh: 103, basis: 'apportioned' }
-    ]
-  })
-  const [press, weld] = t.roots[0].children
-  assert.equal(press.kWh, 124)
-  assert.equal(press.basis, 'measured')
-  assert.equal(weld.basis, 'apportioned')
-  assert.equal(t.roots[0].kWh, undefined, '뿌리의 몫은 분기 표에 없다 — 지어내지 않는다')
-})
-
-test('에너지 자리가 없으면 그림을 만들지 않는다 — 빈 그림은 고장으로 읽힌다', () => {
-  const t = buildEnergyTopology({ locations: [{ id: 'dock-1', type: 'dock' }], equipment: [] })
-  assert.equal(t.roots.length, 0)
-})
-
-/*
- * ── 발전·저장의 **지금 값**을 기호 옆에 (2026-08-18) ─────────────────────────
- * 원천이 태양광 발전량과 축전지 충전율·방전을 보내 주는데도 그림에는 기호만 있었다 — 화면이 아는 사실을
- * 그림이 감추는 것이다. 다만 지금 값은 구간 값과 성격이 다르므로 시각을 함께 나른다(계측이 끊기면
- * 멈춘 값을 지금 값으로 그리게 된다).
- */
-const withSources = () => ({
-  locations: [{ id: 'incoming-1', type: 'incoming', name: '수전' }],
-  equipment: [
-    { id: 'meter-incoming', kind: 'meter', homeLocation: 'incoming-1' },
-    { id: 'pv-roof', kind: 'pv-array', homeLocation: 'incoming-1' },
-    { id: 'ess-1', kind: 'battery', homeLocation: 'incoming-1' }
-  ]
-})
-
-test('종류가 아는 필드만 옮긴다 — 태양광에 충전율을 붙이지 않는다', () => {
-  const t = buildEnergyTopology(withSources(), undefined, [
-    { id: 'pv-roof', kind: 'pv-array', generatedKW: 16, exportKW: 0, soc: 99, measuredAt: '2026-08-18T09:00:00.000Z' },
-    { id: 'ess-1', kind: 'battery', soc: 48, dischargeKW: 200, chargeKW: 0, generatedKW: 7, measuredAt: '2026-08-18T09:00:00.000Z' }
-  ])
-  const gear = new Map(t.roots[0].gear.map(g => [g.id, g]))
-  assert.deepEqual(gear.get('pv-roof')?.live, { generatedKW: 16, exportKW: 0, measuredAt: '2026-08-18T09:00:00.000Z' })
-  assert.deepEqual(gear.get('ess-1')?.live, { soc: 48, dischargeKW: 200, chargeKW: 0, measuredAt: '2026-08-18T09:00:00.000Z' })
-})
-
-test('상태를 주지 않으면 값을 만들지 않는다 — 구조만 그린다', () => {
-  const t = buildEnergyTopology(withSources())
-  for (const g of t.roots[0].gear) assert.equal(g.live, undefined)
-})
-
-test('보내지 않은 필드는 없다 — 0 으로 채우지 않는다', () => {
-  const t = buildEnergyTopology(withSources(), undefined, [{ id: 'ess-1', kind: 'battery', soc: 30 }])
-  const ess = t.roots[0].gear.find(g => g.id === 'ess-1')
-  assert.deepEqual(ess?.live, { soc: 30 })
-  assert.equal(ess?.live?.dischargeKW, undefined, '방전을 보내지 않았으면 모르는 것이다')
-})