@things-factory/headless-twin 10.0.5 → 10.0.6

package/server/service/twin-event/twin-event.ts

@@ -10,8 +10,28 @@ import { Domain, ScalarObject } from '@things-factory/shell'
  * payload 는 simple-json(멀티DB 이식 — postgres/mysql/sqlite/mssql/oracle 공통, DB-specific JSON 타입 금지).
  * (CLAUDE.md: 모든 @ObjectType/@Field 는 영문 description 필수.)
  */
+/*
+ * ── 인덱스 설계 (2026-07-31) ────────────────────────────────────────────────
+ * 이 표는 **인제스트 경로의 뜨거운 append-only 테이블**이다. 인덱스 하나하나가 쓰기 증폭이므로
+ * "있으면 좋을" 인덱스를 붙이지 않는다. 실제 질의 패턴에 대응하는 것만 둔다.
+ *
+ *  ix_0 (domain, instanceId, revision)            원장 기본 정렬·커서 페이징·replay(ASC 주사)
+ *  ix_1 (domain, instanceId, eventTime)           시각 커서(untilTime)·시간창 KPI — 거의 모든 조회가 탄다
+ *  ix_2 (domain, instanceId, eventType, revision) 타입 필터 + 정렬 동시 충족(스케줄 화면 task/equipment)
+ *  ix_3 (domain, instanceId, epc)                 "이 물건의 이력" — Entity360 의 본질 질문
+ *  ix_4 (domain, instanceId, orderId)             "이 오더가 어디까지 갔나"
+ *
+ * bizStep·locationId·moverId 는 컬럼만 두고 인덱스는 두지 않는다 — 한 트윈 안에서 카디널리티가
+ * 낮아(업무단계 몇 개, 위치 수백, 설비 수십) (domain,instanceId) 로 이미 좁혀진 뒤의 잔여 필터로
+ * 충분하고, 뜨거운 표에 인덱스를 더 얹을 값어치가 없다. 저널 하나가 아주 커져서 이 축들의 조회가
+ * 느려지면 그때 측정을 근거로 인덱스를 추가할 일이지, 지레 얹어 쓰기를 무겁게 할 일은 아니다.
+ */
 @Entity()
 @Index('ix_twin_event_0', (e: TwinEvent) => [e.domain, e.instanceId, e.revision], { unique: false })
+@Index('ix_twin_event_1', (e: TwinEvent) => [e.domain, e.instanceId, e.eventTime], { unique: false })
+@Index('ix_twin_event_2', (e: TwinEvent) => [e.domain, e.instanceId, e.eventType, e.revision], { unique: false })
+@Index('ix_twin_event_3', (e: TwinEvent) => [e.domain, e.instanceId, e.epc], { unique: false })
+@Index('ix_twin_event_4', (e: TwinEvent) => [e.domain, e.instanceId, e.orderId], { unique: false })
 @ObjectType({ description: 'Append-only twin event journal record (EPCIS event or operational delta).' })
 export class TwinEvent {
   @PrimaryGeneratedColumn('uuid')
@@ -45,6 +65,34 @@ export class TwinEvent {
   @Field({ nullable: true, description: 'Simulation event time (ISO 8601).' })
   eventTime?: string
 
+  /*
+   * ── 승격된 검색 축 ────────────────────────────────────────────────────────
+   * payload 안에 있던 값을 인제스트 시점에 꺼내 실컬럼으로 둔다(`twin-event-keys.ts` 가 단독 소유).
+   * payload 가 여전히 정본이고 이것들은 **파생 색인**이다 — 새로운 진실이 아니라 찾을 수 있게 하는 장치.
+   * simple-json(TEXT) 안의 값은 5개 DB 드라이버 공통으로 거를 방법이 없어서(멀티DB 호환 규칙상
+   * DB별 JSON 연산자 금지) 승격 외의 선택지가 없다.
+   * 길이 상한 255 는 GS1 식별자 규격 대비 충분하며, 넘치는 값은 조용히 잘리지 않고 경고를 남긴다.
+   */
+  @Column({ length: 255, nullable: true })
+  @Field({ nullable: true, description: 'Business step (CBV bizStep tail), promoted from the payload for indexed filtering.' })
+  bizStep?: string
+
+  @Column({ length: 255, nullable: true })
+  @Field({ nullable: true, description: 'Item identifier (EPC / EPC class / parent id), promoted from the payload for indexed lookup of one item history.' })
+  epc?: string
+
+  @Column({ length: 255, nullable: true })
+  @Field({ nullable: true, description: 'Business transaction identifier (PO / SO), promoted from the payload for indexed lookup of one order history.' })
+  orderId?: string
+
+  @Column({ length: 255, nullable: true })
+  @Field({ nullable: true, description: 'Location identifier (read point, business location, or the plain location an operational delta carries), promoted from the payload for indexed filtering.' })
+  locationId?: string
+
+  @Column({ length: 255, nullable: true })
+  @Field({ nullable: true, description: 'Equipment or mover identifier carried by operational deltas, promoted from the payload so one machine history can be asked for on the server.' })
+  moverId?: string
+
   @Column({ type: 'simple-json', nullable: true })
   @Field(type => ScalarObject, { nullable: true, description: 'Raw canonical envelope (EPCIS event or operational delta) as JSON.' })
   payload?: any

package/server/service/twin-journal/twin-journal-query.ts

@@ -1,11 +1,12 @@
 import { Between, LessThanOrEqual, MoreThanOrEqual } from 'typeorm'
-import { Arg, Ctx, Int, Query, Resolver } from 'type-graphql'
+import { Arg, Args, Ctx, Int, Query, Resolver } from 'type-graphql'
 
-import { getRepository, ScalarObject } from '@things-factory/shell'
+import { buildNextCursor, cursorSortings, getQueryBuilderFromListParams, getRepository, ListParam, ScalarObject } from '@things-factory/shell'
 
 import { TwinEvent } from '../twin-event/twin-event.js'
+import { TwinEventList } from '../twin-event/twin-event-type.js'
 import { TwinEngine } from '../../engine/index.js'
-import { computeTwinKpi } from '../../engine/kpi-query.js'
+import { computeTwinKpi, resolveTwinTargets } from '../../engine/kpi-query.js'
 
 /*
  * 저널 읽기 채널 — 상향 query.
@@ -39,6 +40,81 @@ export class TwinJournalQuery {
     return getRepository(TwinEvent).find({ where, order: { revision: 'DESC' }, take: limit ?? 200 })
   }
 
+  /**
+   * 저널 목록 — things-factory 표준 목록 계약(`ListParam` → `{ items, total }`).
+   *
+   * ── 왜 `twinEvents` 와 따로 두는가 ─────────────────────────────────────────
+   * `twinEvents` 는 배열만 돌려준다. 화면은 자기가 받은 게 전부인지 잘린 건지 알 수 없었고, 그래서
+   * 리스트가 **조용히 잘린 채 "이게 전부" 처럼** 보였다(원장 limit 120 이 대표적). 총건수를 함께
+   * 주면 "48 / 12,904" 라고 말할 수 있고, 사용자는 좁혀야 한다는 사실을 안다.
+   * 기존 호출자를 깨지 않으려고 `twinEvents` 는 그대로 두고 목록 계약을 새로 연다.
+   *
+   * ── 검색이 진짜인 이유 ─────────────────────────────────────────────────────
+   * `searchables` 는 전부 **인덱스 가능한 승격 컬럼**이다(payload JSON 안이 아니라). 프레임워크
+   * 질의 빌더는 `searchables` 에 없는 컬럼의 LIKE 를 경고 후 무시한다 — 인덱스 없는 전체 스캔을
+   * 막기 위해서다. 그 규율에 맞추려고 검색 축을 컬럼으로 승격했다(`twin-event-keys.ts`).
+   *
+   * 정렬 기본값은 revision DESC(최신순) — 저널의 자연 순서이자 ix_twin_event_0 가 그대로 타는 축.
+   */
+  @Query(returns => TwinEventList, {
+    description:
+      'List twin journal events with the standard list contract (filters, pagination, sortings) plus the total match count. ' +
+      'Scope is either one twin (instanceId) or a whole site (spaceId, which folds in every running operational twin co-located there, the same targets twinKpi uses) — one of the two is required. ' +
+      'Searchable fields are the columns promoted out of the payload: epc (item), orderId, locationId, moverId (equipment), bizStep, eventType. ' +
+      'Returns total so a caller can show an honest "shown of total" count instead of silently truncating a long journal. ' +
+      'Defaults to newest first (revision descending) and to a page of 100; limit is capped at 500 per page.'
+  })
+  async twinEventList(
+    @Args(type => ListParam) params: ListParam,
+    @Ctx() context: ResolverContext,
+    @Arg('instanceId', { nullable: true, description: 'Read one twin instance journal.' }) instanceId?: string,
+    @Arg('spaceId', { nullable: true, description: 'Read every running operational twin co-located in this space, merged on the shared time axis.' }) spaceId?: string
+  ): Promise<TwinEventList> {
+    const { domain } = context.state
+    if (!instanceId && !spaceId) throw new Error('either instanceId or spaceId is required')
+    /* 테넌트 격리 — twinKpi 와 같은 규약. 남의 트윈은 빈 결과가 아니라 명시 실패로 알린다
+     * (조용한 빈 목록은 "권한 없음" 과 "데이터 없음" 을 구분할 수 없게 만든다). */
+    if (instanceId && !TwinEngine.owns(domain.id, instanceId)) {
+      throw new Error(`twin instance not found in this tenant: ${instanceId}`)
+    }
+
+    /* 대상 해소는 KPI 와 같은 창구를 쓴다 — 같은 공간을 보면서 화면마다 대상이 달라지면 안 된다. */
+    const instanceIds = await resolveTwinTargets(domain.id, instanceId, spaceId)
+    if (instanceIds.length === 0) return { items: [], total: 0 }
+
+    /* 페이지 상한 — 화면이 실수로(또는 악의로) 저널 전체를 한 번에 달라고 해도 서버가 버틴다. */
+    const limit = Math.min(params.pagination?.limit ?? 100, 500)
+    const effective: ListParam = {
+      ...params,
+      pagination: { page: params.pagination?.page ?? 1, limit },
+      /* 기본 정렬은 시각 내림차순 — 여러 트윈을 합칠 때 공통 축은 revision(트윈별 카운터)이 아니라
+       * **시각**이다. revision 으로 섞으면 서로 다른 트윈의 무관한 카운터가 뒤엉킨다. */
+      sortings: params.sortings?.length ? params.sortings : [{ name: 'eventTime', desc: true }]
+    }
+
+    const qb = getQueryBuilderFromListParams({
+      repository: getRepository(TwinEvent),
+      params: effective,
+      domain,
+      /* 전부 인덱스 가능한 승격 컬럼 — 자유 검색어는 서버가 이 축들로 펼친다. */
+      searchables: ['epc', 'orderId', 'locationId', 'moverId', 'bizStep', 'eventType'],
+      /* 정렬은 인덱스가 받쳐 주는 축으로만 — 큰 저널에서 임의 컬럼 정렬은 전체 정렬 스캔이다. */
+      sortables: ['eventTime', 'revision', 'eventType', 'bizStep'],
+      defaultLimit: 100,
+      maxLimit: 500
+    })
+    /* 대상 범위는 호출자가 필터로 빼먹을 수 있는 값이 아니다 — 계약상 필수라 여기서 강제한다. */
+    qb.andWhere(`${qb.alias}.instanceId IN (:...instanceIds)`, { instanceIds })
+
+    const [items, total] = await qb.getManyAndCount()
+
+    /* 다음 커서는 **이번 페이지의 마지막 행**에서 만든다. 페이지가 상한보다 짧으면 뒤가 없다. */
+    const axes = cursorSortings(effective.sortings, 'id')
+    const nextCursor = items.length === limit ? buildNextCursor(items[items.length - 1], axes) : undefined
+
+    return { items, total, nextCursor }
+  }
+
   /**
    * 업무 KPI — 시간창 처리량·소요시간·자원 점유. 저널을 **접어서** 만든다(새 계측을 심지 않는다).
    *

package/test/kpi-fold.test.ts

@@ -154,6 +154,28 @@ test('payload 가 envelope 없이 델타만 와도 읽는다 — 저장 형태
   assert.equal(r.workTime.avgMs, 20000)
 })
 
+test('완료가 재전송되면 한 건으로 센다 — 처리량·자원 점유가 부풀려지지 않게', () => {
+  /* 공정 타임라인과 KPI 가 같은 저널을 다르게 짝지어 다른 답을 냈다(타임라인 1건 / KPI 2건).
+   * 두 구현이 있었기 때문이고, 규칙은 하나여야 한다: **완료는 작업당 하나, 나중 것이 사실.** */
+  const r = foldKpi(
+    [
+      task('t1', 'created', 0),
+      task('t1', 'in-progress', 10, 'fk-1'),
+      task('t1', 'completed', 40, 'fk-1'),
+      task('t1', 'completed', 45, 'fk-1') // 재전송
+    ],
+    WINDOW
+  )
+  assert.equal(r.throughput.tasks, 1, '한 건이다')
+  assert.equal(r.workTime.count, 1)
+  assert.equal(r.workTime.avgMs, 35000, '나중 완료(45s) 기준')
+  assert.deepEqual(
+    r.utilization.map(u => [u.resourceId, u.busyMs]),
+    [['fk-1', 35000]],
+    '점유도 한 번만 더한다(예전엔 65초로 부풀려졌다)'
+  )
+})
+
 test('같은 전이가 두 번 와도 착수는 처음 것, 생성은 마지막 것 — 재시도에 흔들리지 않게', () => {
   const r = foldKpi(
     [

package/test/twin-event-keys.test.ts

@@ -0,0 +1,108 @@
+/*
+ * ★ 저널 검색 키 승격 검증 — payload(JSON) 안의 값을 인덱스 가능한 실컬럼으로 꺼내는 규칙.
+ *
+ * 이 규칙이 틀리면 "저널에는 있는데 검색으로는 안 나오는 이벤트" 가 생긴다. 화면에서는 그냥
+ * **없는 것으로 보인다** — 저널에서 가장 나쁜 결함이라 규칙을 테스트로 고정한다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { bizStepOf, epcOf, orderOf, locationOf, moverOf, twinEventKeys } from '../server/service/twin-event/twin-event-keys.ts'
+
+/** EPCIS ObjectEvent 한 건(입고) — 실제 인제스트가 싣는 모양. */
+const EPCIS_OBJECT = {
+  eventType: 'epcis.ObjectEvent',
+  eventTime: '2026-07-31T02:10:00.000Z',
+  data: {
+    bizStep: 'urn:epcglobal:cbv:bizstep:receiving',
+    disposition: 'urn:epcglobal:cbv:disp:in_progress',
+    epcList: ['urn:epc:id:sgtin:0614141.107346.2018'],
+    readPoint: { id: 'urn:epc:id:sgln:0614141.00777.DOCK-3' },
+    bizLocation: { id: 'urn:epc:id:sgln:0614141.00888.0' },
+    bizTransactionList: [{ type: 'urn:epcglobal:cbv:btt:po', bizTransaction: 'urn:epc:id:gdti:0614141.402.2' }]
+  }
+}
+
+test('EPCIS 이벤트에서 네 축이 모두 뽑힌다', () => {
+  const k = twinEventKeys(EPCIS_OBJECT)
+  assert.equal(k.bizStep, 'receiving')
+  assert.equal(k.epc, 'urn:epc:id:sgtin:0614141.107346.2018')
+  assert.equal(k.orderId, 'urn:epc:id:gdti:0614141.402.2')
+  assert.equal(k.locationId, 'urn:epc:id:sgln:0614141.00777.DOCK-3')
+})
+
+test('식별자는 끝마디가 아니라 전체를 저장한다 — 부분일치 검색이 양방향으로 성립해야 한다', () => {
+  const k = twinEventKeys(EPCIS_OBJECT)
+  /* 화면은 '2018' 로 축약해 보여주지만 색인은 원본을 갖는다. contains 검색이라
+   * 끝마디로도 URN 전체로도 찾힌다 — 끝마디만 저장하면 URN 경로가 사라진다. */
+  assert.ok(k.epc!.includes('2018'), '끝마디로 찾을 수 있어야 한다')
+  assert.ok(k.epc!.startsWith('urn:epc:id:sgtin'), 'URN 전체로도 찾을 수 있어야 한다')
+})
+
+test('readPoint 가 없으면 bizLocation 으로 내려간다', () => {
+  const ev = { ...EPCIS_OBJECT, data: { ...EPCIS_OBJECT.data, readPoint: undefined } }
+  assert.equal(locationOf(ev), 'urn:epc:id:sgln:0614141.00888.0')
+})
+
+test('bizStep 이 없으면 이벤트 타입에서 유추한다 — 운영 델타도 단계를 말할 수 있어야 한다', () => {
+  assert.equal(bizStepOf({ eventType: 'task.status', data: { task: 't1' } }), 'task.status')
+  assert.equal(bizStepOf({ eventType: 'epcis.AggregationEvent', data: {} }), 'AggregationEvent')
+})
+
+test('집합 이벤트는 parentID 를, 수량 이벤트는 epcClass 를 품목으로 쓴다', () => {
+  assert.equal(epcOf({ data: { parentID: 'urn:epc:id:sscc:0614141.1234567890' } }), 'urn:epc:id:sscc:0614141.1234567890')
+  assert.equal(epcOf({ data: { quantityList: [{ epcClass: 'urn:epc:idpat:sgtin:0614141.107346.*', quantity: 40 }] } }), 'urn:epc:idpat:sgtin:0614141.107346.*')
+})
+
+test('운영 델타의 오더는 bizTransactionList 가 아니라 order 필드에 있다', () => {
+  assert.equal(orderOf({ eventType: 'order.status', data: { order: 'SO-10021', status: 'released' } }), 'SO-10021')
+})
+
+test('없는 값은 빈 문자열이 아니라 undefined — 결측과 빈값을 섞지 않는다', () => {
+  const k = twinEventKeys({ eventType: 'equipment.status', data: { equipment: 'fork-1', status: 'idle' } })
+  assert.equal(k.epc, undefined)
+  assert.equal(k.orderId, undefined)
+  assert.equal(k.locationId, undefined)
+  assert.equal(k.moverId, undefined)
+  /* bizStep 은 이벤트 타입에서 유추되므로 남는다 — 이건 결측이 아니다. */
+  assert.equal(k.bizStep, 'equipment.status')
+})
+
+test('설비·무버 축 — 운영 델타의 moverId 를 뽑는다', () => {
+  const ev = { eventType: 'equipment.status', data: { moverId: 'fork-3', status: 'down', location: 'rack-1' } }
+  assert.equal(moverOf(ev), 'fork-3')
+  const k = twinEventKeys(ev)
+  assert.equal(k.moverId, 'fork-3')
+  /* 운영 델타는 readPoint/bizLocation 이 없다 — 평범한 location 을 위치로 받는다.
+   * 빠뜨리면 "이 설비가 어디서 무엇을 했나" 가 위치 축에서 통째로 사라진다. */
+  assert.equal(k.locationId, 'rack-1')
+})
+
+test('EPCIS 의 readPoint 는 운영 델타의 location 보다 우선한다', () => {
+  assert.equal(locationOf({ data: { readPoint: { id: 'DOCK-1' }, location: 'rack-9' } }), 'DOCK-1')
+})
+
+test('payload 가 data 로 감싸이지 않은 모양도 받는다', () => {
+  assert.equal(epcOf({ epcList: ['urn:epc:id:sgtin:1.2.3'] }), 'urn:epc:id:sgtin:1.2.3')
+})
+
+test('상한을 넘는 값은 조용히 사라지지 않는다 — 잘리되 경고가 남는다', () => {
+  const long = 'urn:epc:id:sgtin:' + 'x'.repeat(400)
+  const warned: string[] = []
+  const orig = console.warn
+  console.warn = (...a: unknown[]) => void warned.push(String(a[0]))
+  try {
+    const k = twinEventKeys({ data: { epcList: [long] } })
+    assert.equal(k.epc!.length, 255)
+    assert.equal(warned.length, 1, '잘렸다는 사실이 어딘가에는 남아야 한다')
+    assert.ok(warned[0].includes('epc'))
+  } finally {
+    console.warn = orig
+  }
+})
+
+test('빈 봉투에도 터지지 않는다', () => {
+  const empty = { bizStep: undefined, epc: undefined, orderId: undefined, locationId: undefined, moverId: undefined }
+  assert.deepEqual(twinEventKeys(undefined), empty)
+  assert.deepEqual(twinEventKeys({}), empty)
+})

package/test/warm-start.test.ts

@@ -0,0 +1,78 @@
+/*
+ * ★ 웜스타트 판정 검증 — 재기동하는 커널에 직전 관측 상태를 심을지.
+ *
+ * 이 판정은 **양쪽으로 조용히 틀린다**: 심어야 할 때 안 심으면 있는 재고가 0 으로 보이고
+ * (2026-07-31 hatiolab-wms — 저널에 입고 540·출고 94 인데 재고 화면이 비어 있었다),
+ * 벤치에 심으면 용량 측정이 오염된다. 둘 다 화면에는 아무 이상이 없어 보인다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { planWarmStart } from '../server/engine/warm-start.ts'
+
+const STATE = {
+  nodes: [{ id: 'dock-recv' }, { id: 'rack-1' }],
+  items: [{ epc: 'a' }, { epc: 'b' }, { epc: 'c' }],
+  movers: [{ id: 'fork-1' }],
+  orders: [{ id: 'SO-1', kind: 'outbound', status: 'created', progress: 0.5 }],
+  tasks: [{ id: 't1' }]
+}
+
+test('상태가 있으면 심는다 — 재고·노드·무버', () => {
+  const plan = planWarmStart(STATE, undefined, true)
+  assert.equal(plan.action, 'hydrate')
+  if (plan.action !== 'hydrate') return
+  assert.equal(plan.itemCount, 3)
+  assert.equal(plan.moverCount, 1)
+  assert.deepEqual(plan.seed.nodes, STATE.nodes)
+})
+
+test('오더는 심지 않는다 — 스냅샷에 requested/fulfilled 가 없어 지어내야 하기 때문', () => {
+  const plan = planWarmStart(STATE, undefined, true)
+  assert.equal(plan.action, 'hydrate')
+  if (plan.action !== 'hydrate') return
+  assert.deepEqual(Object.keys(plan.seed).sort(), ['items', 'movers', 'nodes'])
+  assert.equal((plan.seed as any).orders, undefined)
+  assert.equal((plan.seed as any).tasks, undefined)
+})
+
+test('벤치 트윈에는 심지 않는다 — 새 시작에서 용량을 재는 것이 목적이다', () => {
+  const plan = planWarmStart(STATE, 'bench', true)
+  assert.deepEqual(plan, { action: 'skip', reason: 'bench' })
+})
+
+test('벤치 판정은 상태 유무보다 먼저다 — 상태가 없어도 이유는 bench 여야 한다', () => {
+  /* 이유가 뒤바뀌면 로그가 "심을 게 없었다" 로 남아, 벤치를 의도적으로 비웠다는 사실이 사라진다. */
+  assert.deepEqual(planWarmStart(null, 'bench', true), { action: 'skip', reason: 'bench' })
+})
+
+test('심을 상태가 없으면 조용히 넘어간다 — 처음 만든 트윈의 정상 경로다', () => {
+  assert.deepEqual(planWarmStart(null, undefined, true), { action: 'skip', reason: 'no-state' })
+  assert.deepEqual(planWarmStart(undefined, undefined, true), { action: 'skip', reason: 'no-state' })
+  assert.deepEqual(planWarmStart({ nodes: [], items: [], movers: [] }, undefined, true), { action: 'skip', reason: 'no-state' })
+})
+
+test('노드만 있어도 심는다 — 구조 배치가 복원되면 화면이 살아난다', () => {
+  const plan = planWarmStart({ nodes: [{ id: 'n1' }], items: [], movers: [] }, undefined, true)
+  assert.equal(plan.action, 'hydrate')
+  if (plan.action !== 'hydrate') return
+  assert.equal(plan.itemCount, 0)
+})
+
+test('커널이 주입을 지원하지 않으면 알린다 — 조용히 빈 채로 뜨면 안 된다', () => {
+  assert.deepEqual(planWarmStart(STATE, undefined, false), { action: 'skip', reason: 'unsupported' })
+})
+
+test('심을 게 없으면 미지원이어도 경고할 일이 아니다', () => {
+  /* 미지원 경고가 매 기동마다 뜨면 진짜 경고가 묻힌다. */
+  assert.deepEqual(planWarmStart(null, undefined, false), { action: 'skip', reason: 'no-state' })
+})
+
+test('빠진 배열은 빈 배열로 다뤄지되 없는 것을 지어내지 않는다', () => {
+  const plan = planWarmStart({ items: [{ epc: 'a' }] } as any, undefined, true)
+  assert.equal(plan.action, 'hydrate')
+  if (plan.action !== 'hydrate') return
+  assert.deepEqual(plan.seed.nodes, [])
+  assert.deepEqual(plan.seed.movers, [])
+  assert.equal(plan.itemCount, 1)
+})