@things-factory/headless-twin 10.0.5 → 10.0.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/headless-twin",
-  "version": "10.0.5",
+  "version": "10.0.7",
   "main": "dist-server/index.js",
   "things-factory": true,
   "author": "heartyoh <heartyoh@hatiolab.com>",
@@ -25,11 +25,11 @@
     "test": "node --test test/*.test.ts"
   },
   "dependencies": {
-    "@operato/twin-kernel": "^0.0.6",
-    "@things-factory/auth-base": "^10.0.5",
-    "@things-factory/cache-service": "^10.0.5",
+    "@operato/twin-kernel": "^0.4.0",
+    "@things-factory/auth-base": "^10.0.7",
+    "@things-factory/cache-service": "^10.0.7",
     "@things-factory/env": "^10.0.0",
-    "@things-factory/shell": "^10.0.5"
+    "@things-factory/shell": "^10.0.7"
   },
-  "gitHead": "42240a9b6d504181850ea30188f215434b2dd55f"
+  "gitHead": "fffd94e886b67ed9019993a572a632054e812fa3"
 }

package/server/engine/entity-delta.ts

@@ -1,9 +1,28 @@
 /*
  * 트윈 State 스냅샷 → 라이브 바인딩 delta 목록 (순수 매핑 — pubsub/도메인 무관 → 단위 테스트 가능).
  * publishEntityData 가 이 목록을 엔티티별 시그니처로 dedup 후 data(tag) 채널로 발행한다.
- * payload 계약은 씬 컴포넌트가 소비(twin-storage·mover·equipment·trend·order-tracker·resource-control):
- *   node: occupancy/capacity/status/type · mover: location/motion/status/held/oee(정수 퍼센트) ·
- *   order: status/progress/held · __orders__: 전체 오더 집약(Trackable 뷰).
+ *
+ * ── 규율: 레퍼런스가 아는 것은 **전부** 내보낸다 ────────────────────────────
+ * 트윈에서 사소한 속성은 없다. 소속 구역·소속 팔레트·수량·만료처럼 곁가지로 보이는 값이 실제로는
+ * 구역 롤업·적재 표현·로트 추적의 전제다. 그래서 여기서 **필드를 손으로 골라 담지 않는다.**
+ *
+ * 예전에는 엔티티마다 필요할 것 같은 필드만 열거했고, 그 결과 계약에 있는 것이 조용히 누락됐다
+ * (2026-08-01 감사: 노드 parentId 누락 · 작업 전량 누락 · 물품 전량 누락). 화이트리스트 방식은
+ * **계약이 자라도 화면이 따라오지 못한다** — 커널이 속성을 늘릴 때마다 이 파일을 고쳐야 하고, 고치는
+ * 것을 잊으면 아무 신호 없이 정보가 사라진다.
+ *
+ * 그래서 반대로 한다: **상태 객체가 가진 것을 그대로 통과**시키고, 통과시키지 **않을** 것만 이유와 함께
+ * 열거한다(EXCLUDED). 새 속성은 자동으로 화면에 도달하고, 빼려면 이유를 적어야 한다.
+ *
+ * ── 표식은 도메인 낱말을 훔치지 않는다 ─────────────────────────────────────
+ * 예전 payload 는 엔티티 종류 표식을 `kind` 로 실었다. 그런데 `kind` 는 **도메인의 낱말**이다 —
+ * 무버 kind=cutter, 작업 kind=putaway, 오더 kind=workorder. 표식이 그 이름을 차지하면 도메인 속성을
+ * 실을 자리가 없어진다(같은 병을 오늘 ox-timeline 의 `group` 에서도 고쳤다).
+ * 그래서 표식은 `entity`(우리 이름)로 옮기고 `kind` 는 도메인에 돌려준다.
+ *
+ * payload 계약(씬 컴포넌트가 소비): `entity`(표식) + 그 엔티티의 모든 속성(도메인 `kind` 포함).
+ *   entity = location · equipment · person · asset · order · task · item,
+ *   그리고 집약 태그(__orders__ · __tasks__ · __items__ · __persons__ · __assets__).
  */
 
 export interface EntityDelta {
@@ -11,11 +30,26 @@ export interface EntityDelta {
   data: any
 }
 
-/** 오더 집약 고정 태그 — 클라 provider(ORDERS_TAG)와 일치. */
+/** 집약 고정 태그 — 클라 provider 와 일치해야 한다(런타임 생성 엔티티는 개별 배치가 불가하므로 집약 뷰). */
 export const ORDERS_TAG = '__orders__'
+export const TASKS_TAG = '__tasks__'
+export const ITEMS_TAG = '__items__'
+export const PERSONS_TAG = '__persons__'
+export const ASSETS_TAG = '__assets__'
 
-/** OEE 원시 비율/카운트 → 표시용 정수 퍼센트 + 카운트. 원시 누적 ms(idleMs 등)는 매 delta 증가해
- *  무변화-생략을 무력화하므로 제외(idle 자원의 매초 재방송 억제). oee 미측정이면 undefined. */
+/**
+ * 통과시키지 않는 필드 — **빼는 데는 이유가 필요하다.**
+ *
+ * · `id`/`epc` — 태그로 이미 나가므로 개별 payload 에 중복해 싣지 않는다(집약 뷰에는 넣는다).
+ * · `oee` — 원시 누적(idleMs 등)이 매 delta 증가해 "무변화 생략" 을 무력화한다. shapeOee 로 정형화해 얹는다.
+ */
+const EXCLUDED = new Set(['id', 'epc', 'oee'])
+
+/**
+ * OEE 원시 비율/카운트 → 표시용 정수 퍼센트 + 카운트.
+ * 원시 누적 ms(idleMs 등)는 매 delta 증가해 무변화-생략을 무력화하므로 제외(유휴 자원의 매초 재방송 억제).
+ * oee 미측정이면 undefined.
+ */
 function shapeOee(o: any): any {
   if (!o) return undefined
   return {
@@ -28,22 +62,108 @@ function shapeOee(o: any): any {
   }
 }
 
+/**
+ * 엔티티 하나의 payload — `entity` 표식 + 나머지 전부(도메인 `kind` 포함).
+ *
+ * `undefined` 값은 싣지 않는다(키의 유무가 시그니처를 흔들지 않게). 값이 없는 것과 키가 없는 것은
+ * 소비처에서 같으므로 안전하고, 무변화 생략이 잘 듣는다.
+ */
+function payloadOf(entityKind: string, entity: any): any {
+  /* 표식은 `entity` — 도메인의 `kind` 를 덮지 않는다. */
+  const data: any = { entity: entityKind }
+  for (const [k, v] of Object.entries(entity ?? {})) {
+    if (EXCLUDED.has(k) || v === undefined) continue
+    data[k] = v
+  }
+  return data
+}
+
+/**
+ * 집약 뷰의 항목 — 개별 payload 와 같은 내용 + 식별자.
+ * 집약은 "전체를 한 컴포넌트가 추적" 하는 용도라 식별자가 있어야 한다.
+ */
+function aggregateItem(entity: any, idKey: 'id' | 'epc'): any {
+  const out: any = { [idKey]: entity?.[idKey] }
+  for (const [k, v] of Object.entries(entity ?? {})) {
+    if (k === idKey || k === 'oee' || v === undefined) continue
+    out[k] = v
+  }
+  const shaped = shapeOee(entity?.oee)
+  if (shaped) out.oee = shaped
+  return out
+}
+
+/**
+ * 물품 집약의 상한 — 큰 현장은 물품이 수만 개라, 전량을 매 방송에 실으면 전달이 현장을 느리게 한다.
+ *
+ * **조용히 자르지 않는다**: 넘치면 `total`(전체 수)과 `truncated`(잘린 수)를 함께 실어, 소비처가
+ * "이게 전부" 라고 오해하지 않게 한다. 개별 물품은 태그별 delta 로 따로 나가고 그쪽은 시그니처 dedup
+ * 이 걸려 **변한 것만** 재방송된다.
+ */
+export const ITEMS_AGGREGATE_LIMIT = 500
+
 export function buildEntityDeltas(state: any): EntityDelta[] {
   const out: EntityDelta[] = []
-  for (const n of state?.nodes ?? []) {
-    out.push({ tag: n.id, data: { kind: 'node', occupancy: n.occupancy, capacity: n.capacity, status: n.status, type: n.type } })
+
+  for (const n of state?.locations ?? []) {
+    out.push({ tag: n.id, data: payloadOf('location', n) })
+  }
+  for (const m of state?.equipment ?? []) {
+    /* Mobile(location/motion) + Operable(status/held) + Processable(oee) — 한 payload 로.
+     * oee 만 정형화가 필요해 따로 얹는다(나머지는 통과). */
+    const data = payloadOf('equipment', m)
+    const oee = shapeOee(m?.oee)
+    if (oee) data.oee = oee
+    out.push({ tag: m.id, data })
   }
-  for (const m of state?.movers ?? []) {
-    // Mobile(location/motion) + Operable(status/held) + Processable(oee) 를 한 payload 로.
-    out.push({ tag: m.id, data: { kind: 'mover', location: m.location, motion: m.motion, status: m.status, held: m.held, oee: shapeOee(m.oee) } })
+  /* 사람 — 설비와 별개 엔티티다. 같은 통과 규칙(가진 것을 전부 내보낸다). */
+  for (const p of state?.persons ?? []) {
+    out.push({ tag: p.id, data: payloadOf('person', p) })
+  }
+  /* 물리 자산(반복사용) — 물품도 설비도 아닌 네 번째 자원. */
+  for (const a of state?.assets ?? []) {
+    out.push({ tag: a.id, data: payloadOf('asset', a) })
   }
   for (const o of state?.orders ?? []) {
-    out.push({ tag: o.id, data: { kind: 'order', status: o.status, progress: o.progress, held: o.held } })
+    out.push({ tag: o.id, data: payloadOf('order', o) })
+  }
+  for (const t of state?.tasks ?? []) {
+    out.push({ tag: t.id, data: payloadOf('task', t) })
+  }
+  for (const it of state?.items ?? []) {
+    /* 물품의 태그는 epc(개체 식별자) — 노드·무버와 달리 id 가 아니다. */
+    if (it?.epc) out.push({ tag: it.epc, data: payloadOf('item', it) })
   }
-  // 집약(Trackable) — 오더는 런타임 생성이라 개별 배치 불가 → 한 컴포넌트가 전체 추적(집약 N:M). 항상 방출.
+
+  /* ── 집약 뷰 ──────────────────────────────────────────────────────────────
+   * 런타임에 생기고 사라지는 엔티티(오더·작업·물품)는 보드에 개별 배치할 수 없다 → 한 컴포넌트가
+   * 전체를 추적하는 집약 태그를 항상 방출한다. */
+  const orders = state?.orders ?? []
+  out.push({ tag: ORDERS_TAG, data: { entity: 'orders', orders: orders.map((o: any) => aggregateItem(o, 'id')) } })
+
+  const tasks = state?.tasks ?? []
+  out.push({ tag: TASKS_TAG, data: { entity: 'tasks', tasks: tasks.map((t: any) => aggregateItem(t, 'id')) } })
+
+  /* 사람 집약 — 인원은 보드에 개별 배치할 수도 있지만(설비처럼), 전체를 한눈에 보는 소비처도 있다.
+   * 인원을 선언하지 않은 트윈에서는 빈 배열이 나간다(없음과 모름을 구별). */
+  const persons = state?.persons ?? []
+  out.push({ tag: PERSONS_TAG, data: { entity: 'persons', persons: persons.map((p: any) => aggregateItem(p, 'id')) } })
+
+  const assets = state?.assets ?? []
+  out.push({ tag: ASSETS_TAG, data: { entity: 'assets', assets: assets.map((a: any) => aggregateItem(a, 'id')) } })
+
+  const items = state?.items ?? []
+  const shown = items.slice(0, ITEMS_AGGREGATE_LIMIT)
   out.push({
-    tag: ORDERS_TAG,
-    data: { kind: 'orders', orders: (state?.orders ?? []).map((o: any) => ({ id: o.id, kind: o.kind, status: o.status, progress: o.progress, held: o.held })) }
+    tag: ITEMS_TAG,
+    data: {
+      entity: 'items',
+      items: shown.map((it: any) => aggregateItem(it, 'epc')),
+      total: items.length,
+      /* 잘렸으면 그 사실을 말한다 — "이게 전부" 로 읽히면 재고를 과소 판단한다. */
+      ...(items.length > shown.length ? { truncated: items.length - shown.length } : {})
+    }
   })
+
   return out
 }

package/server/engine/index.ts

@@ -2,3 +2,7 @@ export * from './twin-engine.js'
 export * from './canonical-ingest.js'
 export * from './kpi-fold.js'
 export * from './kpi-query.js'
+export * from './spec-coverage.js'
+export * from './travel-estimator.js'
+export * from './measured-estimator.js'
+export * from './model-basis.js'

package/server/engine/kpi-fold.ts

@@ -19,6 +19,14 @@
  * · DB·커널을 모른다. 입력은 평범한 배열이고 출력은 평범한 객체다(테스트가 값싸다).
  */
 
+/*
+ * 짝맞춤은 **커널이 소유한다**(`foldTaskRecords`). 완료는 작업당 하나·나중 것이 사실, 착수는 처음 것,
+ * 종류·오더는 어느 전이에서든 — 그 규칙은 커널 상태 기계에서 나오는 지식이다. 여기서 다시 적었더니
+ * 공정 타임라인과 **다른 답**을 냈다(재전송된 완료를 두 건으로 세어 처리량·점유가 부풀려졌다).
+ * 이 파일은 이제 "접힌 기록 → 창 지표" 만 한다.
+ */
+import { foldTaskRecords, activeShiftAt, type TaskFacets, type WorkCalendarEntry } from '@operato/twin-kernel'
+
 /** 저널 한 줄 — 필요한 것만(엔티티·typeorm 비의존). */
 export interface KpiEvent {
   eventType?: string
@@ -36,6 +44,11 @@ export interface KpiWindow {
 export interface DurationStats {
   /** 짝이 맞아 계산된 건수. */
   count: number
+  /**
+   * 하위 꼬리 — **분포를 양쪽에서 접지하기 위해** 낸다.
+   * p50·p90 만 있으면 아래쪽 퍼짐을 위쪽에서 거울처럼 베껴 쓸 수밖에 없다(발명). 관측이 말하게 한다.
+   */
+  p10Ms: number
   p50Ms: number
   p90Ms: number
   avgMs: number
@@ -48,10 +61,11 @@ export interface DurationStats {
  * 축을 못 내면 AI 도 못 낸다 — 그래서 축은 계산 층의 능력이어야 한다.
  *
  *   resource  자원별(누가 했나)      taskKind  작업 종류별(무엇을 했나)
- *   node      도착 지점별(어디서)    order     오더별(무엇을 위해)
+ *   location  도착 지점별(어디서)    order     오더별(무엇을 위해)
  *   area      구역별 — 노드→구역 지도가 필요하다(이벤트에 없다. 호출부가 준다)
+ *   shift     교대별(언제) — 완료 시각 + 현장의 시각 기준에서 **계산한다**(이벤트에 없다)
  */
-export type KpiGroupBy = 'resource' | 'taskKind' | 'node' | 'order' | 'area'
+export type KpiGroupBy = 'resource' | 'taskKind' | 'location' | 'order' | 'area' | 'shift'
 
 export interface KpiGroup {
   /** 축의 값(자원 id·작업 종류·노드 id·오더 id·구역 id). 값이 없던 기록은 'unknown'. */
@@ -107,7 +121,17 @@ export interface KpiFoldOptions {
    * 노드 → 구역 지도. **이벤트에는 구역이 없다**(노드까지만 있다) — 스냅샷·마스터가 아는 값이라
    * 호출부가 넘긴다. 없으면 구역 축은 'unknown' 으로 모인다(조용히 다른 축으로 바꾸지 않는다).
    */
-  nodeArea?: Record<string, string>
+  locationArea?: Record<string, string>
+  /**
+   * 교대 선언 — **이벤트에는 교대가 없다**(시각만 있다). 현장 마스터가 아는 값이라 호출부가 넘긴다.
+   * 없으면 교대 축은 'unknown' 으로 모인다(다른 축으로 조용히 바꾸지 않는다).
+   */
+  shifts?: WorkCalendarEntry[]
+  /**
+   * 현장의 시각 기준(분) — 교대 축이 `HH:MM` 을 어느 기준으로 읽을지. **공간이 갖는 값**이다
+   * (테넌트가 아니다: 한 테넌트가 다른 시간대의 공장을 함께 가질 수 있다). 없으면 UTC.
+   */
+  utcOffsetMinutes?: number
   /**
    * 축의 상한(기본 20). 넘치면 잘라내고 **잘린 축의 수와 그 안의 건수를 함께 알린다**.
    *
@@ -121,14 +145,6 @@ export interface KpiFoldOptions {
  * 축의 값은 이벤트 payload 에 이미 들어 있다(`TaskStatusDelta`: kind·orderId·fromNode·toNode·
  * resourceRef). 새 계측을 심을 필요가 없다 — **이미 쌓인 저널을 다르게 묶기만** 한다.
  */
-interface TaskFacets {
-  resource?: string
-  taskKind?: string
-  /** 작업이 **도착한** 지점. 없으면 출발 지점(둘 다 없으면 축은 'unknown'). */
-  node?: string
-  order?: string
-}
-
 /** 창 안에 완료된 한 건의 기록 — 통계의 원료이자 관점 축의 원료. */
 interface CompletionRecord {
   taskId: string
@@ -139,23 +155,6 @@ interface CompletionRecord {
   waitMs?: number
 }
 
-/**
- * 이 작업에 대해 본 축의 값을 기억한다 — **처음 본 값을 남긴다**.
- *
- * 왜 처음 것인가: 작업의 종류·소속 오더는 생성 시점에 정해지고 이후 전이는 그것을 되풀이할 뿐이다.
- * 반면 노드는 진행에 따라 바뀌므로 **마지막 것**(가장 최근 도착지)이 사실이다.
- */
-function rememberFacets(store: Map<string, TaskFacets>, id: string, d: any): void {
-  const prev = store.get(id) ?? {}
-  const node = d.toNode ?? d.fromNode
-  store.set(id, {
-    resource: prev.resource ?? (d.resourceRef || undefined),
-    taskKind: prev.taskKind ?? (d.kind || undefined),
-    order: prev.order ?? (d.orderId || undefined),
-    node: node || prev.node
-  })
-}
-
 /** 이 기록이 요청한 축에서 어느 값에 속하는가. 값이 없으면 'unknown'(조용히 버리지 않는다). */
 function facetKey(rec: CompletionRecord, options: KpiFoldOptions): string {
   const f = rec.facets
@@ -163,15 +162,30 @@ function facetKey(rec: CompletionRecord, options: KpiFoldOptions): string {
     case 'resource':
       return f.resource ?? 'unknown'
     case 'taskKind':
-      return f.taskKind ?? 'unknown'
-    case 'node':
-      return f.node ?? 'unknown'
+      return f.kind ?? 'unknown'
+    case 'location':
+      return f.location ?? 'unknown'
     case 'order':
       return f.order ?? 'unknown'
     case 'area':
       /* 구역은 이벤트 밖의 지식이다 — 지도가 없으면 없다고 말한다(노드 id 로 대체하면 사용자가
        * 그것을 구역으로 오해한다). */
-      return (f.node && options.nodeArea?.[f.node]) ?? 'unknown'
+      return (f.location && options.locationArea?.[f.location]) ?? 'unknown'
+    case 'shift':
+      /*
+       * 교대는 **저널에 찍혀 있지 않다 — 계산한다.**
+       *
+       * 이벤트에 교대 이름을 스탬프하면 두 가지가 무너진다: ① 같은 사실이 두 곳에 생기고,
+       * ② 나중에 교대 시간을 고치면 **과거가 옛 구분으로 굳어** 다시 셀 수 없다. 교대는
+       * `완료 시각 + 현장의 시각 기준 + 교대 선언`에서 나오는 순수 파생이므로 여기서 낸다 —
+       * 라이브·히스토리·예측이 **커널과 같은 함수**(`activeShiftOf`)를 쓴다.
+       *
+       * 선언이 없으면 'unknown' 이다. 교대를 나눠 놓지 않은 현장에 이름을 지어내지 않는다.
+       */
+      if (!options.shifts?.length) return 'unknown'
+      /* 시각까지 넘긴다 — **휴일에 일어난 일은 어느 교대에도 속하지 않는다.** 되풀이만 보면 그날 서지도
+         않은 교대에 집계돼, 교대별 성과가 조용히 거짓이 된다. */
+      return activeShiftAt(options.shifts, rec.at, options.utcOffsetMinutes) ?? 'unknown'
     default:
       return 'unknown'
   }
@@ -235,11 +249,12 @@ function quantile(sorted: number[], q: number): number {
 }
 
 function stats(values: number[]): DurationStats {
-  if (values.length === 0) return { count: 0, p50Ms: 0, p90Ms: 0, avgMs: 0 }
+  if (values.length === 0) return { count: 0, p10Ms: 0, p50Ms: 0, p90Ms: 0, avgMs: 0 }
   const sorted = [...values].sort((a, b) => a - b)
   const sum = sorted.reduce((a, b) => a + b, 0)
   return {
     count: sorted.length,
+    p10Ms: quantile(sorted, 0.1),
     p50Ms: quantile(sorted, 0.5),
     p90Ms: quantile(sorted, 0.9),
     avgMs: Math.round(sum / sorted.length)
@@ -257,13 +272,8 @@ function stats(values: number[]): DurationStats {
  * (고정 오프셋은 상쇄된다). 파싱 불가한 줄은 버린다.
  */
 export function foldKpi(events: KpiEvent[], window: KpiWindow, options: KpiFoldOptions = {}): KpiResult {
-  /* 작업별 이정표 시각 — 마지막 값을 남긴다(재시도로 같은 전이가 두 번 오면 나중 것이 사실). */
-  const created = new Map<string, number>()
-  const started = new Map<string, number>()
-  /* 축의 값은 **어느 전이에서든** 올 수 있다(완료 이벤트에 kind 가 빠져 있고 생성에만 있는 구현이 있다).
-   * 그래서 작업별로 한 번 본 값을 기억한다 — 축이 이벤트 모양에 따라 통째로 비는 것을 막는다. */
-  const facets = new Map<string, TaskFacets>()
-  const completedTasks: { id: string; at: number; resourceId?: string }[] = []
+  /* 작업 짝맞춤은 **커널 규칙**으로(중복 구현 금지 — 두 곳에 적으면 같은 저널로 다른 답이 나온다). */
+  const { records: tasks } = foldTaskRecords(events.filter(e => e.eventType === 'task.status'))
   let completedOrders = 0
   let seen = 0
   let inWindow = 0
@@ -275,15 +285,6 @@ export function foldKpi(events: KpiEvent[], window: KpiWindow, options: KpiFoldO
     if (at >= window.fromMs && at <= window.toMs) inWindow++
     const d = e.payload?.data ?? e.payload ?? {}
 
-    if (e.eventType === 'task.status') {
-      const id = d.taskId
-      if (!id) continue
-      rememberFacets(facets, id, d)
-      if (d.status === 'created') created.set(id, at)
-      else if (d.status === 'in-progress' && !started.has(id)) started.set(id, at)
-      else if (d.status === 'completed') completedTasks.push({ id, at, resourceId: d.resourceRef })
-      continue
-    }
     if (e.eventType === 'order.status') {
       /* 오더 완료 어휘는 도메인 소유다 — 코어가 강제하지 않는다. 그래서 이름을 하나로 못 박지 않고
        * 완료로 읽히는 표현을 넓게 받는다(그 밖은 세지 않는다). */
@@ -305,19 +306,21 @@ export function foldKpi(events: KpiEvent[], window: KpiWindow, options: KpiFoldO
   let unpairedLead = 0
   let unpairedWork = 0
 
-  for (const t of completedTasks) {
-    if (t.at < window.fromMs || t.at > window.toMs) continue // 성과는 완료 시점으로 센다
+  for (const t of tasks) {
+    const completed = t.completedMs
+    if (completed === undefined) continue // 아직 완료되지 않은 작업 — 성과로 세지 않는다
+    if (completed < window.fromMs || completed > window.toMs) continue // 성과는 완료 시점으로 센다
     tasksInWindow++
-    const c = created.get(t.id)
-    const s = started.get(t.id)
-    const rec: CompletionRecord = { taskId: t.id, at: t.at, facets: facets.get(t.id) ?? {} }
-    if (t.resourceId) rec.facets = { ...rec.facets, resource: t.resourceId }
-    if (c !== undefined && t.at >= c) leads.push((rec.leadMs = t.at - c))
+    const c = t.createdMs
+    const s = t.startedMs
+    const rec: CompletionRecord = { taskId: t.taskId, at: completed, facets: t.facets }
+    const resource = rec.facets.resource
+    if (c !== undefined && completed >= c) leads.push((rec.leadMs = completed - c))
     else unpairedLead++
-    if (s !== undefined && t.at >= s) {
-      const busy = t.at - s
+    if (s !== undefined && completed >= s) {
+      const busy = completed - s
       works.push((rec.workMs = busy))
-      if (t.resourceId) busyByResource.set(t.resourceId, (busyByResource.get(t.resourceId) ?? 0) + busy)
+      if (resource) busyByResource.set(resource, (busyByResource.get(resource) ?? 0) + busy)
     } else {
       unpairedWork++
     }