@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/operations-capability-db.test.ts

@@ -1,165 +0,0 @@
-/*
- * ★ 생산 능력 질의 — **트윈 하나를 두고 "지금 더 받을 수 있나" 를 물을 길.**
- *
- * 커널이 계산과 표준 등식을 지킨다(kernel/test/operations-capability). 이 검사가 지키는 것은 그 앞의
- * 배선이다 — 그리고 여기서 지켜야 할 규율은 `twinCapacity` 와 같다:
- *
- *  · **대상은 등록부가 정한다** — 떠 있는 런타임만 훑으면 "안 떠 있어서 안 보이는 것" 과 "없는 것" 이
- *    구별되지 않는다. 화면은 그 둘을 다르게 말해야 한다.
- *  · **공정을 선언하지 않은 트윈은 판정 대상이 아니다** — 0 으로 채우면 "야드가 병목" 이라는 없는
- *    사실이 생긴다.
- *  · **구간은 부르는 쪽이 말한다** — 기본값을 두면 화면마다 다른 구간을 보면서 같은 값으로 읽는다.
- */
-import { test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { createRequire } from 'node:module'
-import type { DataSource } from 'typeorm'
-
-const req = createRequire(import.meta.url)
-const { NamingStrategy, addDataSource, entities: shellEntities, Domain } = req('@things-factory/shell')
-const { entities: authEntities } = req('@things-factory/auth-base')
-const { entities: twinEntities } = req('../dist-server/service/index.js')
-const { TwinEngine } = req('../dist-server/engine/index.js')
-const { TwinJournalQuery } = req('../dist-server/service/twin-journal/twin-journal-query.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-let q: any
-let ctx: any
-
-const MES = 'cap-mes'
-const WMS = 'cap-wms'
-const WINDOW = { fromTime: '2026-01-05T00:00:00.000Z', toTime: '2026-01-06T00:00:00.000Z' }
-
-/** 절단 하나 — 설비 2대·사람 2명, 사이클 1시간. 24시간 창이면 상한 48대. */
-const mesMaster = (): any => ({
-  source: MES,
-  system: 'mes',
-  siteName: '능력 공장',
-  space: { spaceId: 'cap-site', width: 60, depth: 40, unit: 'm' },
-  locations: [
-    { id: 'raw-store', type: 'raw-store', role: 'location', name: '자재 보관', capacity: 100 },
-    { id: 'cut-station', type: 'cut-station', role: 'location', name: '절단', capacity: 10 },
-    { id: 'fg-store', type: 'fg-store', role: 'location', name: '완제품', capacity: 100 }
-  ],
-  equipment: [
-    { id: 'cutter-1', kind: 'cutter', homeLocationId: 'cut-station' },
-    { id: 'cutter-2', kind: 'cutter', homeLocationId: 'cut-station' }
-  ],
-  personnelClasses: [{ id: 'cutter-op', description: '절단 작업자' }],
-  persons: [
-    { id: 'c-1', personnelClassIds: ['cutter-op'], homeLocationId: 'cut-station' },
-    { id: 'c-2', personnelClassIds: ['cutter-op'], homeLocationId: 'cut-station' }
-  ],
-  operations: [
-    {
-      key: 'cut', label: '절단', intent: 'process', locationType: 'cut-station', resourceType: 'cutter',
-      duration: 'PT1H',
-      equipmentSpecification: [{ equipmentClass: 'cutter', quantity: 1 }],
-      personnelSpecification: [{ personnelClass: 'cutter-op', quantity: 1 }]
-    }
-  ],
-  productionSpec: {
-    /* 레시피 생산은 자재 키를 GS1 로 풀 수 있어야 한다 — 커널이 없으면 기동을 거절한다(정확한 거절이다). */
-    companyPrefix: '0614141',
-    binding: { steel: '077101', frame: '078101' },
-    definition: {
-      materials: [{ id: 'steel' }, { id: 'frame' }],
-      routes: [{ key: 'r', steps: ['cut'] }],
-      recipes: [{ key: 'rc', label: '프레임', route: 'r', inputs: [{ material: 'steel', qty: 1 }], outputs: [{ material: 'frame', qty: 1 }] }]
-    }
-  }
-})
-
-/** 공정을 선언하지 않는 창고 — 판정 대상이 아님을 확인하는 대조군. */
-const wmsMaster = (): any => ({
-  source: WMS,
-  system: 'wms',
-  siteName: '능력 창고',
-  space: { spaceId: 'cap-wh', width: 40, depth: 30, unit: 'm' },
-  locations: [
-    { id: 'dock', type: 'dock', role: 'location', name: '도크', capacity: 50 },
-    { id: 'bin-1', type: 'storage', role: 'location', name: '빈1', capacity: 20 }
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock' }]
-})
-
-before(async () => {
-  ds = new TypeOrmDataSource({
-    type: 'sqlite',
-    database: ':memory:',
-    synchronize: true,
-    dropSchema: true,
-    namingStrategy: new NamingStrategy(),
-    entities: [...shellEntities, ...authEntities, ...twinEntities],
-    logging: false
-  })
-  await ds.initialize()
-  addDataSource('default', ds)
-  const d = await ds.getRepository(Domain).save({ name: 'cap-test', subdomain: 'cap-test' } as any)
-  domainId = d.id
-  q = new TwinJournalQuery()
-  ctx = { state: { domain: { id: domainId } } }
-
-  await TwinEngine.ingestMaster(domainId, mesMaster(), 'reset')
-  await TwinEngine.ingestMaster(domainId, wmsMaster(), 'reset')
-})
-
-after(async () => {
-  for (const id of [MES, WMS]) await TwinEngine.stop(domainId, id).catch(() => {})
-  await ds?.destroy()
-})
-
-const ask = (instanceId: string) =>
-  q.twinOperationsCapability(instanceId, undefined, 24, WINDOW.fromTime, WINDOW.toTime, WINDOW.fromTime, ctx)
-
-test('실행 중이 아니면 그 사실을 알린다 — "없는 것" 과 구별된다', async () => {
-  const rows = await ask(MES)
-  assert.equal(rows.length, 1, '등록부에 있으면 목록에 선다(떠 있지 않아도)')
-  assert.equal(rows[0].reason, 'not-running')
-  assert.equal(rows[0].report, undefined, '값을 지어내지 않는다')
-})
-
-test('돌고 있으면 구간의 양을 종류로 갈라 낸다 — 표준 등식이 성립한다', async () => {
-  await TwinEngine.startFromRegistry(domainId, MES, 'reset')
-  const rows = await ask(MES)
-  assert.equal(rows[0].reason, undefined)
-
-  const report = rows[0].report
-  assert.equal(report.operationsType, 'Production', '표준 열거값을 그대로 낸다')
-  assert.equal(report.window.fromTime, WINDOW.fromTime)
-  assert.equal(report.window.workingHours, 24, '캘린더 선언이 없으면 종일 가동으로 본다')
-
-  const cut = report.perOperation.find((o: any) => o.operation === 'cut')
-  assert.ok(cut, '선언한 공정이 보고서에 있어야 한다')
-  assert.equal(cut.total, 48, '설비 2대·사람 2명·사이클 1시간 → 하루 48대')
-  assert.equal(cut.total, cut.committed + cut.available + cut.unattainable, 'Total = Committed + Available + Unattainable')
-})
-
-test('공정을 선언하지 않은 트윈은 판정 대상이 아니다 — 0 으로 채우면 없는 병목이 생긴다', async () => {
-  await TwinEngine.startFromRegistry(domainId, WMS, 'reset')
-  const rows = await q.twinOperationsCapability(WMS, undefined, 24, WINDOW.fromTime, WINDOW.toTime, WINDOW.fromTime, ctx)
-  assert.equal(rows[0].reason, 'no-operations')
-  assert.equal(rows[0].report, undefined)
-})
-
-test('구간은 호출하는 쪽이 지정한다 — 뒤집힌 구간·잘못된 시각은 거절한다', async () => {
-  await assert.rejects(
-    () => q.twinOperationsCapability(MES, undefined, 24, WINDOW.toTime, WINDOW.fromTime, undefined, ctx),
-    /inverted/
-  )
-  await assert.rejects(
-    () => q.twinOperationsCapability(MES, undefined, 24, 'not-a-time', WINDOW.toTime, undefined, ctx),
-    /valid ISO time/
-  )
-  await assert.rejects(() => q.twinOperationsCapability(MES, undefined, 0, WINDOW.fromTime, WINDOW.toTime, undefined, ctx))
-})
-
-test('남의 테넌트 트윈은 열리지 않는다 — 능력은 현장의 사실이다', async () => {
-  const other = { state: { domain: { id: 'no-such-domain' } } }
-  await assert.rejects(
-    () => q.twinOperationsCapability(MES, undefined, 24, WINDOW.fromTime, WINDOW.toTime, undefined, other),
-    /not found in this tenant/
-  )
-})

package/test/order-and-transaction-split.test.ts

@@ -1,107 +0,0 @@
-/*
- * ★ **오더 식별자와 거래 식별자는 다른 칸에 든다** — 한 칸에 두 낱말이 들어가던 자리.
- *
- * ── 실측 (2026-09-05) ──────────────────────────────────────────────────────
- * 승격 칸 `order_id` 하나가 두 낱말을 담고 있었다.
- *
- *   order.status                order-1                          내부 오더 id
- *   epcis.TransformationEvent   urn:epc:id:gdti:9521321.403.1    GS1 거래 식별자
- *
- * 한 오더의 이력이 **색인 안에서 두 쪽으로 갈라진다.** 어느 이름으로 물어도 절반만 나오고,
- * 오류는 나지 않는다. 어휘가 섞인 행 10,004개.
- *
- * 그 갈라짐이 막은 것은 「이 개체를 어느 레시피로 만들었나」다 — 답은 오더 사건에 이미 있는데
- * (`recipeKey`, 실측 328,021/328,021), 변환 사건에서 그 오더로 건너갈 색인이 없었다.
- *
- * ── 왜 이 검사인가 ────────────────────────────────────────────────────────
- * 「합치면 편하다」는 힘이 계속 작용한다 — 값을 채우는 관점에서는 한 칸이 간단해 보이고, 실제로
- * 그 이유로 합쳐져 있었다(옛 주석이 「오더를 스스로 말하는 사건은 그 말을 그대로 쓴다」고 적고
- * 있었다). 그러니 갈라 둔 것을 **값으로** 못 박는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { bizTransactionOf, orderOf, twinEventKeys } from '../server/service/twin-event/twin-event-keys.js'
-import { SUBJECT_KINDS, subjectsOf } from '../server/service/twin-subject/event-subjects.js'
-
-const GDTI = 'urn:epc:id:gdti:9521321.403.1'
-
-/** 실측한 변환 사건의 모양 — GDTI 만 있고 오더 id 는 없다. */
-const transformation = {
-  eventType: 'epcis.TransformationEvent',
-  data: {
-    type: 'TransformationEvent',
-    inputEPCList: ['urn:epc:id:sgtin:9521321.011111.1'],
-    outputEPCList: ['urn:epc:id:sgtin:9521321.033333.1'],
-    bizTransactionList: [{ type: 'urn:epcglobal:cbv:btt:prodorder', bizTransaction: GDTI }]
-  }
-}
-
-/** 실측한 오더 사건의 모양 — 둘 다 든다. 이것이 다리다. */
-const orderStatus = {
-  eventType: 'order.status',
-  data: { orderId: 'order-1', status: 'created', recipeKey: 'trailer', bizTransaction: GDTI }
-}
-
-/* ── 갈라져 있나 ─────────────────────────────────────────────────────────── */
-
-test('★ 변환 사건의 GDTI 는 거래 칸에 든다 — 오더 칸에 앉지 않는다', () => {
-  assert.equal(bizTransactionOf(transformation), GDTI)
-  assert.equal(orderOf(transformation), undefined, 'GDTI 가 오더 식별자 자리에 앉았다')
-})
-
-test('★ 오더 사건은 두 칸을 다 든다 — 이것이 EPCIS 에서 오더로 건너가는 다리다', () => {
-  const keys = twinEventKeys(orderStatus)
-  assert.equal(keys.orderId, 'order-1')
-  assert.equal(keys.bizTransaction, GDTI)
-})
-
-test('★ 두 사건이 같은 거래 값으로 이어진다 — 문자열까지 같아야 색인이 잇는다', () => {
-  /*
-   * 이 검사가 이 변경의 목적이다. 값이 한 글자라도 다르면 색인 조회가 0을 내고, 그 0은
-   * 「그런 오더가 없다」와 구별되지 않는다.
-   */
-  assert.equal(twinEventKeys(transformation).bizTransaction, twinEventKeys(orderStatus).bizTransaction)
-})
-
-test('★ 오더 사건에서 레시피를 읽을 수 있다 — 짐작하지 않아도 되는 근거', () => {
-  /* 자재로 되짚어 첫 레시피를 고르던 자리가 이 값으로 대체된다. */
-  assert.equal((orderStatus.data as any).recipeKey, 'trailer')
-})
-
-/* ── 합쳐지지 않았나 ──────────────────────────────────────────────────────── */
-
-test('★ 오더 칸이 거래로 되돌아가지 않는다 — 옛 되돌림(fallback)이 살아나면 빨강', () => {
-  /*
-   * 옛 코드: `d.orderId ?? d.bizTransactionList?.[0]?.bizTransaction`.
-   * 그 한 줄이 돌아오면 아래가 GDTI 를 내고, 두 낱말이 다시 한 칸에 든다.
-   */
-  const onlyTx = { eventType: 'epcis.ObjectEvent', data: { bizTransactionList: [{ bizTransaction: GDTI }] } }
-  assert.equal(orderOf(onlyTx), undefined, '오더 칸이 거래 값으로 되돌아간다')
-  assert.equal(bizTransactionOf(onlyTx), GDTI)
-})
-
-test('★ 주체 표도 갈라 적는다 — 거래가 오더 이름으로 앉지 않는다', () => {
-  const subjects = subjectsOf(transformation)
-  const kinds = (id: string) => subjects.filter(s => s.id === id).map(s => s.kind)
-
-  assert.deepEqual(kinds(GDTI), ['transaction'], `GDTI 가 붙은 종류가 다르다: ${JSON.stringify(subjects)}`)
-  assert.ok(SUBJECT_KINDS.includes('transaction' as any), '거래 종류가 목록에 없다')
-})
-
-test('★ 오더 사건은 두 주체를 다 낸다', () => {
-  const subjects = subjectsOf(orderStatus)
-  const has = (kind: string, id: string) => subjects.some(s => s.kind === kind && s.id === id)
-
-  assert.ok(has('order', 'order-1'), `오더 주체가 없다: ${JSON.stringify(subjects)}`)
-  assert.ok(has('transaction', GDTI), `거래 주체가 없다: ${JSON.stringify(subjects)}`)
-})
-
-/* ── 검사가 실제로 무언가를 재나 ─────────────────────────────────────────── */
-
-test('★ 이 검사가 실제로 무언가를 잰다 — 견준 것이 0이면 빨강', () => {
-  const keys = twinEventKeys(orderStatus)
-  assert.ok(Object.values(keys).filter(v => v !== undefined).length >= 3, `승격 키를 ${JSON.stringify(keys)} 만 뽑았다`)
-  assert.ok(subjectsOf(orderStatus).length >= 2, '주체가 둘도 안 나왔다')
-  assert.ok(subjectsOf(transformation).length >= 1, '변환 사건에서 주체가 하나도 안 나왔다')
-})

package/test/order-fold-host.test.ts

@@ -1,112 +0,0 @@
-/*
- * **호스트가 끝난 오더를 접고, 방송이 「최근 T 완료」를 싣는다** — ADR-0092 3 단계.
- *
- * 커널은 스스로 접지 않는다. 호스트가 체크포인트 직전에 부르고, `__orders__` 방송이 창 안 수(계약의 `finishedFlowOrdersWithin`)와
- * 접힌 수를 싣는다. 판정이 요구한 시험 둘: 같은 상태로 두 번 만든 방송의 칩 값이 같다 · KPI 의 같은 구간 수와 같다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-import { createRequire } from 'node:module'
-
-import { buildEntityDeltas, ordersTag } from '../shared/entity-delta.ts'
-import { foldForCheckpoint } from '../server/engine/checkpoint-fold.ts'
-import { planLiveContinuity } from '../server/engine/warm-start.ts'
-import { foldKpi } from '../server/engine/kpi-fold.ts'
-
-const req = createRequire(import.meta.url)
-const { WmsKernel } = req('@operato/twin-kernel')
-const { foldedOrderCount } = req('@operato/ops-contract')
-
-const H = 60 * 60 * 1000
-const GTIN = 'urn:epc:idpat:sgtin:0614141.012345.*'
-const BOARD = {
-  identity: { namespaces: ['https://twin.test/order-fold-host'] },
-  locations: [
-    { id: 'dock-recv', type: 'dock', capacity: 2000 },
-    { id: 'bin-1', type: 'storage', capacity: 20000 },
-    { id: 'staging', type: 'staging', capacity: 2000 },
-    { id: 'dock-ship', type: 'dock-ship', capacity: 2000 }
-  ],
-  equipment: Array.from({ length: 12 }, (_, i) => ({ id: `fk-${i}`, kind: 'forklift', homeLocation: 'dock-recv' }))
-}
-
-/** 바쁜 창고(도착 240 · 출고 200/h)를 돌리며 한 시간마다 접는다 — 체크포인트처럼. N 이 먼저 걸리는 규모다. */
-function busy(hours: number) {
-  const k: any = new WmsKernel('host-fold')
-  const events: any[] = []
-  k.onEvent((e: any) => events.push(e))
-  k.loadTwinModel(BOARD)
-  k.scenario.load({
-    seed: 9,
-    generators: [
-      { kind: 'inbound-arrival', rate: { distribution: 'poisson', meanPerHour: 240 }, content: { skuMix: [{ gtin: GTIN, weight: 1 }], qtyPerLine: { min: 1, max: 1 } } },
-      { kind: 'outbound-order', rate: { distribution: 'poisson', meanPerHour: 200 }, content: { skuMix: [{ gtin: GTIN, weight: 1 }], qtyPerLine: { min: 1, max: 1 } } }
-    ]
-  })
-  k.scenario.start()
-  for (let h = 0; h < hours; h++) {
-    for (let i = 0; i < H / 5000; i++) k.tick(5000)
-    foldForCheckpoint({ mode: 'sim', kernel: k })
-  }
-  return { k, events }
-}
-
-const ordersAggregate = (state: any) => buildEntityDeltas(state, 'host-fold').find(d => d.tag === ordersTag('host-fold'))!.data as any
-
-test('★ 체크포인트 직전의 접기는 그 구동의 커널을 부른다 — 미러는 projector, 시뮬은 kernel', () => {
-  const calls: string[] = []
-  const fake = (name: string) => ({ foldFinishedOrders: () => (calls.push(name), 3) })
-  assert.equal(foldForCheckpoint({ mode: 'live', projector: fake('projector'), kernel: fake('kernel') }), 3)
-  assert.equal(foldForCheckpoint({ mode: 'sim', projector: fake('projector'), kernel: fake('kernel') }), 3)
-  assert.deepEqual(calls, ['projector', 'kernel'])
-  assert.equal(foldForCheckpoint({ mode: 'sim', kernel: {} }), 0, '접는 문이 없는 옛 커널은 건드리지 않는다')
-  assert.equal(foldForCheckpoint(undefined), 0)
-})
-
-test('persistSnapshot 은 상태를 뜨기 전에 접는다 — 접힌 쪽이 그 체크포인트와 같은 때에 적힌다', () => {
-  const src = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const body = src.slice(src.indexOf('static async persistSnapshot('))
-  const fold = body.indexOf('foldForCheckpoint(inst)')
-  const snap = body.indexOf('unwrapState(this.snapshot(domainId, instanceId))')
-  assert.ok(fold > 0 && snap > 0 && fold < snap, '접기가 상태를 뜨는 것보다 먼저여야 한다')
-})
-
-test('★ 방송은 창 안 수를 싣고, 같은 상태로 두 번 만들어도 칩 값이 같다', () => {
-  const { k } = busy(26)
-  const state = k.getSnapshot()
-  const a = ordersAggregate(state).finished
-  const b = ordersAggregate(state).finished
-  assert.ok(a, '창 안 수가 실린다')
-  assert.deepEqual(a, b)
-  assert.equal(a.windowMs, 24 * H)
-  assert.ok(ordersAggregate(state).folded > 0, '접힌 수도 실린다')
-  const hotDone = state.orders.filter((o: any) => o.terminalAtMs !== undefined).length
-  assert.ok(hotDone <= 1000 && a.count > 1000, `N 에서 멈추지 않는다 — 뜨거운 종결 ${hotDone}, 창 안 ${a.count}`)
-})
-
-test('★ 창 안 수는 KPI 의 같은 구간 종결 수와 같다 — 같은 판정, 같은 원천', () => {
-  const { k, events } = busy(26)
-  const state = k.getSnapshot()
-  const finished = ordersAggregate(state).finished
-  const kpi = foldKpi(
-    events.map(e => ({ eventType: e.eventType, eventTime: e.eventTime, payload: e })),
-    { fromMs: finished.fromMs, toMs: finished.toMs }
-  )
-  assert.equal(finished.count, kpi.throughput.orders)
-  const sum = Object.values(finished.byStatus as Record<string, number>).reduce((s, n) => s + n, 0)
-  assert.equal(sum, finished.count, '상태별 수의 합은 그 수다')
-})
-
-test('지금을 모르는 상태에는 창 안 수를 싣지 않는다 — 0 으로 메우지 않는다', () => {
-  const agg = ordersAggregate({ orders: [], nowTime: undefined })
-  assert.equal(agg.finished, undefined)
-})
-
-test('이어가기 씨앗이 접힌 오더를 나른다 — 원천을 다시 읽는 미러가 세는 수와 경계를 잃지 않게', () => {
-  const { k } = busy(26)
-  const plan = planLiveContinuity({ revision: 1, state: k.getSnapshot() })
-  assert.equal(plan.foldedOrders, true)
-  assert.equal(foldedOrderCount((plan.seed as any).foldedOrders), foldedOrderCount(k.getSnapshot().foldedOrders))
-})

package/test/producer-guard.test.ts

@@ -1,66 +0,0 @@
-/*
- * ★ A twin made by one producer is not rebuilt by another (chief architect ruling, 2026-09-24).
- *
- * On 09-24 the warehouse connection `wms-miratek`, imported with site id `miratek`, landed on the running
- * plant mirror `miratek` and replaced its structure. The row already named its producer. These pin the
- * rule, and the last test pins where it runs: before `ingestMaster` writes anything.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-import { INSTANCE_TAKEN, producerOf, refuseOverwriteByAnotherProducer } from '../server/engine/producer-guard.ts'
-
-const PLANT = { kind: 'reference', source: 'mes-miratek' }
-
-test('a different connection is refused, and the refusal names the connection that made the twin', () => {
-  const r = refuseOverwriteByAnotherProducer('miratek', PLANT, { kind: 'reference', source: 'wms-miratek', siteId: 'miratek' })
-  assert.equal(r?.code, INSTANCE_TAKEN)
-  assert.deepEqual(r?.params, { instance: 'miratek', producer: 'mes-miratek' })
-})
-
-test('the same producer re-reading its own twin passes, whatever else its origin carries', () => {
-  /* Import sites carry { kind, source } at one call and add siteId · spaceId at another (resolver 168 vs 889). */
-  assert.equal(refuseOverwriteByAnotherProducer('miratek', PLANT, { ...PLANT, siteId: 'miratek', spaceId: 'miratek' }), null)
-  /* Resync hands the stored origin back as it is (masterFromOrigin). */
-  assert.equal(refuseOverwriteByAnotherProducer('miratek', { ...PLANT, siteId: 'miratek' }, { ...PLANT, siteId: 'miratek' }), null)
-  /* A template re-run with other knobs is the same template. */
-  assert.equal(
-    refuseOverwriteByAnotherProducer('w1', { kind: 'template', templateId: 'wms-unit-load', params: { racks: 4 } }, { kind: 'template', templateId: 'wms-unit-load', params: { racks: 9 } }),
-    null
-  )
-})
-
-test('a template and a reference are different producers even with the same name', () => {
-  assert.equal(refuseOverwriteByAnotherProducer('x', { kind: 'template', templateId: 'x' }, { kind: 'reference', source: 'x' })?.code, INSTANCE_TAKEN)
-})
-
-test('(a) a twin nobody can name is not rebuilt by a declared producer', () => {
-  const r = refuseOverwriteByAnotherProducer('old', undefined, PLANT)
-  assert.deepEqual(r?.params, { instance: 'old', producer: 'undeclared' })
-})
-
-test('(b) a declared twin is not rebuilt by an undeclared producer', () => {
-  assert.deepEqual(refuseOverwriteByAnotherProducer('miratek', PLANT, undefined)?.params, { instance: 'miratek', producer: 'mes-miratek' })
-})
-
-test('(c) neither declared passes — the demo seed re-ingesting its own twin at boot', () => {
-  assert.equal(refuseOverwriteByAnotherProducer('rosarito-mes', undefined, undefined), null)
-  assert.equal(refuseOverwriteByAnotherProducer('rosarito-mes', {}, { kind: '' }), null)
-})
-
-test('a kind the guard does not know is still somebody, not nobody', () => {
-  assert.notEqual(producerOf({ kind: 'bench', source: 'hatio-yard' }), undefined)
-})
-
-test('ingestMaster refuses before its first write — a refusal after it would leave the twin half-changed', () => {
-  const engine = readFileSync(fileURLToPath(new URL('../server/engine/twin-engine.ts', import.meta.url)), 'utf-8')
-  const at = engine.indexOf('static async ingestMaster(')
-  const body = engine.slice(at, engine.indexOf('\n  static ', at + 10))
-  const guard = body.indexOf('refuseOverwriteByAnotherProducer(')
-  const firstWrite = body.search(/\.save\(|\.update\(|\.insert\(|\.delete\(/)
-  assert.ok(guard > 0, 'ingestMaster no longer asks who made the twin')
-  assert.ok(firstWrite > 0, 'no write found — this check would pass by finding nothing')
-  assert.ok(guard < firstWrite, 'the refusal must come before the first write')
-})