@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/twin-model-tree-db.test.ts

@@ -1,209 +0,0 @@
-/*
- * ★ 다단 전개(BOM) — **자재가 자재를 품는 트리가 아니다.**
- *
- * 표준(ISA-95)이 택한 모양은 자재와 레시피가 번갈아 나오는 그래프다:
- * 완제품 ←산출— 레시피 —투입→ 부품, 그리고 그 부품이 또 어느 레시피의 산출이면 거기서 다시 내려간다.
- * 우리 선언(`ops.rel.input`·`ops.rel.output`)이 이미 그 두 홉이므로 **새 선언 없이** 재귀가 된다.
- *
- * 여기서 지키는 것:
- *  · 패턴을 코드가 알지 않는다 — 선언 그래프에서 자기 축으로 돌아오는 순환을 찾는다
- *  · **알리지 않고 고르지 않는다** — 순환이 여럿이면 후보를 내고 멈춘다(방향이 뒤집힌 전개는
- *    틀린 답이 아니라 **반대의 답**이라 화면만 보고는 구별되지 않는다)
- *  · 수량은 곱해 내려가되, **모르면 곱하지 않는다**(1 로 메우면 윗단 합계가 통째로 거짓이 된다)
- *  · 사이클을 만나면 다시 파지 않고 말한다
- *  · 상한에서 끊기면 끊겼다고 말한다
- */
-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 { TwinModelTreeQuery } = req('../dist-server/service/twin-model/twin-model-tree-query.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-let q: any
-let ctx: any
-
-const INSTANCE = 'bom-probe'
-
-/**
- * 3단 BOM — 완제품 → 하위조립 → 원자재.
- *   trailer  ← trailer-line  ← { frame ×1, axle ×2 }
- *   frame    ← frame-line    ← { steel ×4 }
- */
-const master = (extra: any = {}): any => ({
-  source: INSTANCE,
-  system: 'mes',
-  siteName: 'BOM 공장',
-  space: { width: 60, depth: 30, unit: 'm' },
-  locations: [{ id: 'line', type: 'weld-station', role: 'location', capacity: 10 }],
-  equipment: [{ id: 'welder-1', kind: 'welder', homeLocationId: 'line' }],
-  productionSpec: {
-    definition: {
-      materials: [{ id: 'trailer' }, { id: 'frame' }, { id: 'axle' }, { id: 'steel' }],
-      recipes: [
-        { key: 'trailer-line', label: '트레일러', inputs: [{ material: 'frame', qty: 1 }, { material: 'axle', qty: 2 }], outputs: [{ material: 'trailer', qty: 1 }] },
-        { key: 'frame-line', label: '프레임', inputs: [{ material: 'steel', qty: 4 }], outputs: [{ material: 'frame', qty: 1 }] }
-      ],
-      ...extra
-    }
-  }
-})
-
-const explode = (itemId: string, opts: any = {}) =>
-  q.twinModelTree(INSTANCE, 'materials', itemId, ctx, 'ops.rel.output', 'ops.rel.input', opts.maxDepth, opts.maxItems)
-
-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: 'bom-test', subdomain: 'bom-test' } as any)
-  domainId = d.id
-  q = new TwinModelTreeQuery()
-  ctx = { state: { domain: { id: domainId } } }
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-after(async () => {
-  await TwinEngine.stop(domainId, INSTANCE).catch(() => {})
-  await ds?.destroy()
-})
-
-test('다단으로 내려간다 — 자재가 자재를 품지 않아도 전개된다', async () => {
-  const t = await explode('trailer')
-  const byDepth = (n: number) => t.items.filter((x: any) => x.depth === n).map((x: any) => x.id).sort()
-
-  assert.deepEqual(byDepth(0), ['trailer'])
-  assert.deepEqual(byDepth(1), ['axle', 'frame'], '레시피를 거쳐 1단이 나온다')
-  assert.deepEqual(byDepth(2), ['steel'], '프레임이 또 어느 레시피의 산출이므로 거기서 더 내려간다')
-})
-
-test('수량을 곱해 내려간다 — 그리고 모르면 곱하지 않는다', async () => {
-  const t = await explode('trailer')
-  const qty = (id: string) => t.items.find((n: any) => n.id === id)?.qty
-  assert.equal(qty('frame'), 1)
-  assert.equal(qty('axle'), 2)
-  assert.equal(qty('steel'), 4, '프레임 1개당 강재 4 → 트레일러 1대당 4')
-  assert.equal(t.qtyIncomplete, false)
-
-  /* 수량이 빠진 선언이 섞이면 그 아래 합계는 성립하지 않는다 — 1 로 메우지 않고 그렇게 말한다. */
-  const noQty = master({
-    recipes: [
-      { key: 'trailer-line', label: 't', inputs: [{ material: 'frame' }], outputs: [{ material: 'trailer', qty: 1 }] },
-      { key: 'frame-line', label: 'f', inputs: [{ material: 'steel', qty: 4 }], outputs: [{ material: 'frame', qty: 1 }] }
-    ]
-  })
-  await TwinEngine.ingestMaster(domainId, noQty, 'reset')
-  const t2 = await explode('trailer')
-  assert.equal(t2.items.find((n: any) => n.id === 'frame').qty, null, '모르는 수량을 1 로 메우지 않는다')
-  assert.equal(t2.items.find((n: any) => n.id === 'steel').qty, null, '모르는 값 아래는 전부 모르는 값이다')
-  assert.equal(t2.qtyIncomplete, true, '합계가 성립하지 않는다는 사실을 낸다')
-
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-test('역전개도 같은 선언으로 — 방향만 뒤집는다', async () => {
-  /* "이 강재를 쓰는 것은 무엇인가" — 투입으로 들어와 산출로 나간다. */
-  const up = await q.twinModelTree(INSTANCE, 'materials', 'steel', ctx, 'ops.rel.input', 'ops.rel.output')
-  assert.deepEqual(up.items.filter((n: any) => n.depth === 1).map((n: any) => n.id), ['frame'])
-  assert.deepEqual(up.items.filter((n: any) => n.depth === 2).map((n: any) => n.id), ['trailer'])
-})
-
-test('방향을 안 고르면 아무것도 펼치지 않는다 — 뒤집힌 전개는 틀린 답이 아니라 반대의 답이다', async () => {
-  const t = await q.twinModelTree(INSTANCE, 'materials', 'trailer', ctx)
-  assert.equal(t.reason, 'ambiguous-pattern')
-  assert.equal(t.items.length, 0, '한쪽을 집으면 아무도 모른 채 반대 답을 본다')
-  assert.ok(t.patterns.length >= 2, '고를 수 있게 후보를 낸다')
-})
-
-test('어떤 순환을 따라 펼쳤는지 밝힌다 — 화면만 보고는 방향을 구별할 수 없다', async () => {
-  const t = await explode('trailer')
-  assert.equal(t.pattern.inVia, 'ops.rel.output')
-  assert.equal(t.pattern.outVia, 'ops.rel.input')
-  assert.equal(t.pattern.through, 'recipes')
-})
-
-test('사이클은 다시 탐색하지 않고 알린다', async () => {
-  /* 강재가 트레일러에서 나온다고 선언하면(재활용) 그래프가 순환한다. 파고 들면 돌아 나오지 못한다. */
-  const loop = master({
-    recipes: [
-      { key: 'trailer-line', label: 't', inputs: [{ material: 'frame', qty: 1 }], outputs: [{ material: 'trailer', qty: 1 }] },
-      { key: 'frame-line', label: 'f', inputs: [{ material: 'trailer', qty: 1 }], outputs: [{ material: 'frame', qty: 1 }] }
-    ]
-  })
-  await TwinEngine.ingestMaster(domainId, loop, 'reset')
-  const t = await explode('trailer')
-  assert.ok(t.items.length < 10, '무한히 자라지 않는다')
-  assert.ok(t.cycles.length > 0, '사이클을 만났다는 사실을 말한다')
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-test('상한에서 끊기면 끊겼다고 알린다 — 알리지 않고 자르지 않는다', async () => {
-  const shallow = await explode('trailer', { maxDepth: 1 })
-  assert.equal(shallow.truncated.depth, true)
-  assert.deepEqual(shallow.items.filter((n: any) => n.depth === 2), [], '깊이 상한 아래는 안 판다')
-  /* 너비 우선이라 **얕은 층은 온전하다** — 깊이 우선이면 한 가지만 깊게 파고 끊긴다. */
-  assert.deepEqual(shallow.items.filter((n: any) => n.depth === 1).map((n: any) => n.id).sort(), ['axle', 'frame'])
-})
-
-test('선언에 없는 자재를 참조하면 그 사실이 드러난다', async () => {
-  const ghost = master({
-    recipes: [
-      { key: 'trailer-line', label: 't', inputs: [{ material: 'no-such-part', qty: 1 }], outputs: [{ material: 'trailer', qty: 1 }] }
-    ]
-  })
-  await TwinEngine.ingestMaster(domainId, ghost, 'reset')
-  const t = await explode('trailer')
-  const child = t.items.find((n: any) => n.id === 'no-such-part')
-  assert.ok(child, '가리켜진 것은 그리되')
-  assert.equal(child.known, false, '선언에 없다는 사실을 함께 낸다(있는 척하지 않는다)')
-  await TwinEngine.ingestMaster(domainId, master(), 'reset')
-})
-
-test('★ 선언에 없는 축을 거치면 터지지 않고 **왜 못 하는지 말한다**', async () => {
-  /*
-   * ── 실측으로 터진 것 (2026-08-24) ────────────────────────────────────────
-   * 이 전개는 **트윈 모델의 선언**을 읽는다(`axisInfo(...).path` 로 모델 안을 찾아 들어간다). 그런데
-   * 커널 카탈로그의 축 중 셋은 **선언되는 것이 아니라 일어나는 것**이다 — `orders`·`tasks`·`items`
-   * 는 사건이 만들고 끝나면 사라진다. 모델이 그 목록을 가질 수 없으므로 `path` 가 비어 있다.
-   *
-   *   Cannot read properties of undefined (reading 'split')
-   *
-   * ★ **터진 것은 요청한 축이 아니라 「거쳐 가는 축」이다.** `locations` 를 물으면 그 순환이 `tasks` 를
-   * 거치는데(작업이 `from`·`at` 으로 자리를 두 번 가리킨다) 그 `tasks` 에 경로가 없다. 그래서 요청한
-   * 축만 지켜서는 막히지 않는다 — 처음에 그렇게 고쳤다가 이 시험이 잡았다.
-   *
-   * 그리고 빈 트리로 답하면 화면이 「이어진 것이 없다」로 읽는데 그것은 거짓이다 — 작업은 자리를
-   * 가리키고 있고, 다만 이 질의가 그것을 아는 곳이 아니다.
-   */
-  const q = new TwinModelTreeQuery()
-  const ctx = { state: { domain: { id: domainId } } } as any
-
-  /* 두 홉을 지정해야 순환이 하나로 정해진다 — 안 지정하면 앞 갈래(모호함)에서 답한다. */
-  const loc = await q.twinModelTree(INSTANCE, 'locations', 'st-a', ctx, 'ops.rel.from', 'ops.rel.at')
-  assert.ok(loc, 'locations: 터지지 않는다')
-  assert.deepEqual(loc.items, [], 'locations: 펼친 것이 없다')
-  assert.equal(loc.reason, 'not-declared-in-model', 'locations: 왜 못 하는지 말한다(거쳐 갈 축이 선언에 없다)')
-
-  /* 자기참조 순환이 아예 없는 축은 그 사실을 말한다 — 이유가 다르면 낱말도 달라야 한다. */
-  for (const axis of ['orders', 'tasks', 'items']) {
-    const r = await q.twinModelTree(INSTANCE, axis, 'anything', ctx)
-    assert.ok(r, `${axis}: 터지지 않는다`)
-    assert.equal(r.reason, 'no-recursive-relation', `${axis}: 순환이 없다는 사실을 말한다`)
-  }
-})

package/test/twin-origin-resync.test.ts

@@ -1,133 +0,0 @@
-/*
- * ★ 트윈은 자기 원본을 기억한다 — **기억하지 않으면 다시 읽을 수 없다.**
- *
- * 트윈은 원본을 비출 뿐이므로(ADR-0028) 원본이 달라지면 다시 읽어야 한다. 그런데 트윈은
- * "내가 무엇에서 나왔나" 를 남기지 않았다 — 어댑터로 들어온 트윈에는 `TwinReference` 행이
- * 있었지만 템플릿으로 세운 트윈에는 아무 표식도 없었다. 그 트윈은 **첫날의 모습에 영원히
- * 머문다.** 실제로 이 앱의 트윈 둘이 그 상태였다(`twinReferences` 도 비었고 `source` 도 null).
- *
- * 여기서 지키는 것 셋:
- *  · 인제스트가 원천을 각인한다 — 원천이 무엇이든 한 자리에
- *  · 원천을 모르는 재프로비전이 **이미 아는 것을 지우지 않는다** — 한 번 지우면 다시 못 읽는다
- *  · 못 읽는 트윈은 **못 읽는다고 말한다** — 짐작으로 아무 원본이나 집지 않는다
- *
- * Since 2026-09-24 (chief architect ruling, engine/producer-guard.ts) a re-provision that does not come
- * from the twin's own producer is **refused** rather than applied: a silent one used to keep the origin
- * but replace the structure, and a different producer used to replace both — the second is how the
- * plant mirror `miratek` got the warehouse's structure. The two tests below now pin the refusal, and
- * that the refused twin's origin and structure are untouched.
- */
-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 { TwinInstance } = req('../dist-server/service/twin-instance/twin-instance.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const BORN = 'origin-probe'
-const ORPHAN = 'orphan-probe'
-
-const master = (source: string, bins: number, origin?: any): any => ({
-  source,
-  system: 'wms',
-  siteName: '원천 창고',
-  space: { width: 40, depth: 20, unit: 'm' },
-  locations: [
-    { id: 'dock-recv', type: 'dock', role: 'location', name: '입고 도크', capacity: 100 },
-    ...Array.from({ length: bins }, (_, i) => ({ id: `bin-${i + 1}`, type: 'storage', role: 'location', name: `빈${i + 1}`, capacity: 20 }))
-  ],
-  equipment: [{ id: 'fk-1', kind: 'forklift', homeLocationId: 'dock-recv' }],
-  ...(origin ? { origin } : {})
-})
-
-const originOf = async (instanceId: string) =>
-  (await ds.getRepository(TwinInstance).findOne({ where: { instanceId } }))?.origin
-
-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: 'origin-test', subdomain: 'origin-test' } as any)
-  domainId = d.id
-})
-
-after(async () => {
-  for (const id of [BORN, ORPHAN]) await TwinEngine.stop(domainId, id).catch(() => {})
-  await ds?.destroy()
-})
-
-test('인제스트가 원천을 각인한다 — 원천이 무엇이든 한 자리에', async () => {
-  await TwinEngine.ingestMaster(domainId, master(BORN, 3, { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } }), 'reset')
-  assert.deepEqual(await originOf(BORN), { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } })
-})
-
-const TEMPLATE = { kind: 'template', templateId: 'wh-unit-load', params: { bins: 3 } }
-const locationsOf = async (instanceId: string) =>
-  (await ds.getRepository(TwinInstance).findOne({ where: { instanceId } }))?.model?.locations?.length
-
-test('원천을 모르는 재프로비전은 거절된다 — 원천도 구조도 그대로다', async () => {
-  /*
-   * 이 경로는 실제로 있다 — 원천을 모르는 호출자(스크립트·복구·옛 코드)가 같은 트윈을 다시 인제스트한다.
-   * Its origin used to be kept while the structure was replaced by whatever that caller had. It is refused
-   * now (ruling (b)): the twin's own producer re-reads it; anything else deletes it first.
-   */
-  await assert.rejects(TwinEngine.ingestMaster(domainId, master(BORN, 5), 'reset'), (e: any) => {
-    assert.equal(e.code, 'instance-taken-by-another-source')
-    assert.deepEqual(e.params, { instance: BORN, producer: 'wh-unit-load' })
-    return true
-  })
-  assert.deepEqual(await originOf(BORN), TEMPLATE)
-  assert.equal(await locationsOf(BORN), 4, 'the refused master did not land (dock 1 + bins 3)')
-})
-
-test('다른 생산자는 거절된다 — 이름을 대고, 원천도 구조도 그대로다', async () => {
-  await assert.rejects(
-    TwinEngine.ingestMaster(domainId, master(BORN, 5, { kind: 'reference', source: 'oracle-wms' }), 'reset'),
-    (e: any) => e.code === 'instance-taken-by-another-source' && e.params?.producer === 'wh-unit-load'
-  )
-  assert.deepEqual(await originOf(BORN), TEMPLATE)
-  assert.equal(await locationsOf(BORN), 4)
-})
-
-test('같은 생산자가 다시 읽으면 지나간다 — 노브가 달라도', async () => {
-  const again = { ...TEMPLATE, params: { bins: 5 } }
-  await TwinEngine.ingestMaster(domainId, master(BORN, 5, again), 'reset')
-  assert.deepEqual(await originOf(BORN), again)
-  assert.equal(await locationsOf(BORN), 6, 'its own template re-run rebuilds it (dock 1 + bins 5)')
-})
-
-test('원천 없이 태어난 트윈은 원천이 없다 — 짐작해 채우지 않는다', async () => {
-  await TwinEngine.ingestMaster(domainId, master(ORPHAN, 2), 'reset')
-  assert.equal(await originOf(ORPHAN), null, '모르는 것을 아는 척하면 엉뚱한 원본으로 현장을 덮는다')
-})
-
-test('조회가 다시 읽을 수 있는지를 먼저 답한다 — 못 하는 것을 못 한다고 알린다', async () => {
-  const { TwinModelQuery } = req('../dist-server/service/twin-model/twin-model-query.js')
-  const q = new TwinModelQuery()
-  const ctx = { state: { domain: { id: domainId } } } as any
-
-  const born = await q.twinModelSummary(BORN, ctx)
-  assert.equal(born.canResync, true)
-  assert.deepEqual(born.origin, { ...TEMPLATE, params: { bins: 5 } })
-
-  const orphan = await q.twinModelSummary(ORPHAN, ctx)
-  assert.equal(orphan.canResync, false, '버튼을 그대로 내면 누를 때마다 실패한다')
-  assert.equal(orphan.origin, null)
-})

package/test/twin-state-channel.test.ts

@@ -1,111 +0,0 @@
-/*
- * ★ Two tenants, one twin name — each subscriber receives its own tenant's messages and nothing else.
- *
- * The same instanceId (and the same reference source) in two tenants is the expected case: source
- * names such as `sap-ewm-1710` are vocabulary tenants share (`runtime-key.ts`). Until 2026-09-24 both
- * channels filtered on that name alone, so tenant B's subscriber received A's deltas, and the snapshot
- * sent when A subscribed went to B as well.
- *
- * This counts what arrives. A filter test alone would not see a sender that builds its own payload
- * without a domain, so the last two tests read the source: every sender goes through the channel's
- * payload builder, and nothing else names the topic.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { dirname, join, relative } from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-import { TWIN_STATE_TOPIC, twinStateFilter, twinStatePayload } from '../server/engine/twin-state-channel.ts'
-import {
-  REFERENCE_PROGRESS_TOPIC,
-  referenceProgressFilter,
-  referenceProgressPayload
-} from '../server/service/reference/reference-progress-channel.ts'
-
-const A = 'domain-a'
-const B = 'domain-b'
-const SHARED = 'sap-ewm-1710'
-
-/* A pubsub reduced to what matters here: every published payload, and a subscriber's filter over them. */
-function bus() {
-  const sent: { topic: string; payload: any }[] = []
-  return {
-    publish: (topic: string, payload: any) => void sent.push({ topic, payload }),
-    received: (topic: string, keep: (p: any) => boolean) => sent.filter(m => m.topic === topic).map(m => m.payload).filter(keep)
-  }
-}
-
-test('twin-state: B receives none of A\'s snapshot or deltas for a twin of the same name', () => {
-  const b = bus()
-  /* A subscribes (its snapshot goes out), then both tenants' twins tick. */
-  b.publish(TWIN_STATE_TOPIC, twinStatePayload(A, { instanceId: SHARED, kind: 'snapshot', revision: 7, payload: { owner: 'A' } }))
-  b.publish(TWIN_STATE_TOPIC, twinStatePayload(A, { instanceId: SHARED, kind: 'delta', revision: 8 }))
-  b.publish(TWIN_STATE_TOPIC, twinStatePayload(B, { instanceId: SHARED, kind: 'delta', revision: 3 }))
-  b.publish(TWIN_STATE_TOPIC, twinStatePayload(B, { instanceId: 'other-twin', kind: 'delta', revision: 1 }))
-
-  const toB = b.received(TWIN_STATE_TOPIC, twinStateFilter(B, SHARED))
-  assert.deepEqual(toB.map(p => [p.domainId, p.twinState.kind, p.twinState.revision]), [[B, 'delta', 3]])
-
-  const toA = b.received(TWIN_STATE_TOPIC, twinStateFilter(A, SHARED))
-  assert.deepEqual(toA.map(p => [p.twinState.kind, p.twinState.revision]), [['snapshot', 7], ['delta', 8]])
-})
-
-test('twin-reference-progress: B receives none of A\'s import progress for a source of the same name', () => {
-  const b = bus()
-  b.publish(REFERENCE_PROGRESS_TOPIC, referenceProgressPayload(A, { source: SHARED, step: 'master', done: 1, error: 'A: connection refused' }))
-  b.publish(REFERENCE_PROGRESS_TOPIC, referenceProgressPayload(B, { source: SHARED, step: 'master', done: 2 }))
-
-  const toB = b.received(REFERENCE_PROGRESS_TOPIC, referenceProgressFilter(B, SHARED))
-  assert.deepEqual(toB.map(p => [p.domainId, p.twinReferenceProgress.done]), [[B, 2]])
-})
-
-test('a payload cannot be built without a domain', () => {
-  assert.throws(() => twinStatePayload('', { instanceId: SHARED, kind: 'delta' }), /domainId is required/)
-  assert.throws(() => referenceProgressPayload('', { source: SHARED }), /domainId is required/)
-})
-
-/* ── every sender goes through the channel ────────────────────────────────── */
-
-const SERVER = join(dirname(fileURLToPath(import.meta.url)), '..', 'server')
-const CHANNELS = new Set(['engine/twin-state-channel.ts', 'service/reference/reference-progress-channel.ts'])
-
-function serverSources(): { path: string; code: string }[] {
-  const out: { path: string; code: string }[] = []
-  const walk = (dir: string) => {
-    for (const name of readdirSync(dir)) {
-      const p = join(dir, name)
-      if (statSync(p).isDirectory()) walk(p)
-      else if (p.endsWith('.ts')) {
-        /* Comments describe the old shape; count code only. */
-        const code = readFileSync(p, 'utf8').replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1')
-        out.push({ path: relative(SERVER, p), code })
-      }
-    }
-  }
-  walk(SERVER)
-  return out
-}
-
-test('no sender builds a channel payload by hand, and nothing names the topics but the channels', () => {
-  const offenders: string[] = []
-  for (const { path, code } of serverSources()) {
-    if (CHANNELS.has(path)) continue
-    if (/\btwinState\s*:\s*\{/.test(code)) offenders.push(`${path}: builds { twinState: … } by hand`)
-    if (/\btwinReferenceProgress\s*:\s*\{/.test(code)) offenders.push(`${path}: builds { twinReferenceProgress: … } by hand`)
-    if (/['"`]twin-state['"`]/.test(code)) offenders.push(`${path}: names 'twin-state'`)
-    if (/['"`]twin-reference-progress['"`]/.test(code)) offenders.push(`${path}: names 'twin-reference-progress'`)
-  }
-  assert.deepEqual(offenders, [])
-})
-
-test('the senders are really there — the scan above is not passing by finding nothing', () => {
-  const callers = serverSources()
-    .filter(s => !CHANNELS.has(s.path))
-    .map(s => s.code)
-    .join('\n')
-  /* engine: runtime subscription + flush; the subscription's first snapshot. */
-  assert.equal((callers.match(/twinStatePayload\(/g) ?? []).length, 3, 'twinStatePayload call sites')
-  /* resync and import. */
-  assert.equal((callers.match(/referenceProgressPayload\(/g) ?? []).length, 2, 'referenceProgressPayload call sites')
-})

package/test/vocabulary-guard.test.ts

@@ -1,43 +0,0 @@
-/*
- * 어휘 가드 — 규칙은 커널이 한 벌 들고 있고(`@operato/twin-kernel` `retiredVocabularyIn`),
- * 이 테스트는 **자기 패키지 소스를 훑는다.** 판정이 패키지마다 갈릴 수 없다.
- *
- * 계기(2026-08-01): 개명을 손으로 쓸다 같은 실수를 세 번 반복했다. 단어 경계로 찾으면 파생 식별자가
- * 빠지고(`moverCount`·`locationType`), 빠진 것은 다음 파도에서야 드러난다. 그 사이 코드에는 두 어휘가
- * 섞여 있고 다음 사람은 어느 쪽을 믿을지 모른다.
- *
- * 실패하면 위반 목록이 그대로 나온다 — 고치거나, 정당하면 그 줄에 `vocabulary-guard: allow <이유>` 를
- * 남긴다(예외가 코드에 이유와 함께 남는다).
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { retiredVocabularyIn } from '@operato/ops-contract'
-
-const ROOTS = ['server', 'client'].map(d => new URL(`../${d}`, import.meta.url).pathname)
-
-function walk(dir: string, out: string[] = []): string[] {
-  let entries: string[]
-  try { entries = readdirSync(dir) } catch { return out }
-  for (const e of entries) {
-    const p = join(dir, e)
-    if (statSync(p).isDirectory()) walk(p, out)
-    else if (p.endsWith('.ts') && !p.endsWith('.d.ts')) out.push(p)
-  }
-  return out
-}
-
-test('소스에 은퇴한 어휘(location·mover)가 남아 있지 않다', () => {
-  const bad: string[] = []
-  for (const root of ROOTS) {
-    for (const f of walk(root)) {
-      readFileSync(f, 'utf-8').split('\n').forEach((line, i) => {
-        const hits = retiredVocabularyIn(line)
-        if (hits.length) bad.push(`${f.split('/').slice(-2).join('/')}:${i + 1}  ${[...new Set(hits)].join(', ')}`)
-      })
-    }
-  }
-  assert.deepEqual(bad, [], `은퇴 어휘 ${bad.length}곳:\n${bad.slice(0, 60).join('\n')}${bad.length > 60 ? `\n… ${bad.length - 60} more` : ''}`)
-})

package/test/warm-start-seam.test.ts

@@ -1,162 +0,0 @@
-/*
- * ★ 웜스타트 이음매 검증 — 판정이 만든 씨앗이 **실제 커널에 심기는지**.
- *
- * ── 왜 따로 있나 ────────────────────────────────────────────────────────────
- * `warm-start.test.ts` 는 순수 판정만 본다("무엇을 씨앗에 담기로 했나"). 그것만으로는 부족했다:
- * 재기동 후 주문이 사라진 결함은 판정과 커널 **사이**에 있었기 때문이다. 판정은 오더를 버렸고,
- * 커널은 받을 준비가 되어 있었다. 양쪽 테스트가 각각 초록이어도 이음매는 끊겨 있었다.
- *
- * 특히 이 테스트가 겨누는 것은 **`snap.orders` 경로**다. 커널은 오더를 두 가지로 받는다 —
- * 두 번째 인자(`OrderStatusDelta[]`)와 스냅샷 안(`snap.orders`). 커널 테스트는 두 번째 인자를
- * 쓰고, 호스트 웜스타트는 스냅샷 안을 쓴다. 즉 **호스트가 의존하는 쪽이 검증되지 않은 상태**였다.
- *
- * ── 무엇을 단언하나 ────────────────────────────────────────────────────────
- * 스냅샷의 오더가 남은 데맨드(requested − fulfilled)로 커널에 서고, 이행이 끝난 오더는 서지 않고,
- * 원값이 없는 오더는 알리지 않고 서지 않는다는 것. 숫자를 지어내지 않는다는 규칙이 이음매 끝까지 지켜지는가.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { WmsKernel } from '@operato/twin-kernel'
-
-import { planWarmStart } from '../server/engine/warm-start.ts'
-import { withLiveAttentions } from '../server/engine/live-attentions.ts'
-
-const GTIN = 'urn:epc:idpat:sgtin:0614141.012345.*'
-
-/*
- * 보드 — WMS 출고 흐름(피킹 → 스테이징 → 출하)이 실제로 굴러갈 최소 구성.
- * `staging` 을 빼고 짜 봤더니 오더가 서기만 하고 진행이 0 이었다. 이음매가 아니라 픽스처 문제였다 —
- * 이 테스트가 흐름 요건까지 시험하려는 것이 아니므로 커널 테스트와 같은 네 자리를 쓴다.
- */
-const model = () => ({
-  /* 이 픽스처가 식별자를 만드는 이름공간 — **픽스처마다 다르게** 둔다(같은 접두 아래에서 서로 다른
-     시험의 번호가 부딪치면 표준의 유일성 요구를 깬다, CBV 2.0 §8.2.4). 커널은 선언 없이 팔레트·문서를
-     만들지 않는다(0.7.45 에서 날조 프리픽스를 지웠다). */
-  identity: { namespaces: ['https://twin.test/warm-start-seam'] },
-  locations: [
-    { id: 'dock-recv', type: 'dock', capacity: 100 },
-    { id: 'bin-1', type: 'storage', capacity: 200 },
-    { id: 'staging', type: 'staging', capacity: 100 },
-    { id: 'dock-ship', type: 'dock-ship', capacity: 100 }
-  ],
-  equipment: [
-    { id: 'fk-1', kind: 'forklift', homeLocation: 'dock-recv' },
-    { id: 'fk-2', kind: 'forklift', homeLocation: 'dock-recv' }
-  ]
-})
-
-/** 관측 스냅샷 흉내가 아니라, 스냅샷이 실제로 들고 오는 모양(일곱 축 중 필요한 것). */
-const observed = (orders: unknown[]) => ({
-  locations: model().locations.map(n => ({ ...n, occupancy: 0, status: 'idle' })),
-  items: Array.from({ length: 20 }, (_, i) => ({
-    epc: `urn:epc:id:sgtin:0614141.012345.${i}`,
-    location: 'bin-1',
-    gtin: GTIN,
-    qty: 1
-  })),
-  equipment: model().equipment.map(m => ({ ...m, location: 'dock-recv', status: 'idle' })),
-  tasks: [],
-  orders
-})
-
-/** 판정 → 주입. 호스트 `warmStart` 가 하는 일과 같은 순서로 잇는다. */
-function seedKernel(state: ReturnType<typeof observed>) {
-  const plan = planWarmStart(state, undefined, true)
-  assert.equal(plan.action, 'hydrate', '심기로 판정해야 한다')
-  if (plan.action !== 'hydrate') throw new Error('unreachable')
-  const k = new WmsKernel('t')
-  k.loadTwinModel(model() as any)
-  ;(k as any).hydrateObserved(plan.seed)
-  return { k, plan }
-}
-
-test('스냅샷 안의 오더가 커널에 선다 — 남은 데맨드로', () => {
-  const { k, plan } = seedKernel(
-    observed([{ id: 'SO-1', kind: 'outbound', status: 'in-progress', requested: 20, fulfilled: 5, lines: [{ gtin: GTIN, requested: 20, fulfilled: 5 }] }])
-  )
-  assert.equal(plan.orderCount, 1)
-  const o = (k as any).orders.get('SO-1')
-  assert.ok(o, '재기동 후 진행 중 주문이 커널에 있어야 한다 — 사라지던 결함의 회귀 방지')
-  assert.equal(o.requested, 15, '남은 데맨드 15(20−5)로 서야 한다 — 원값이 아니라 남은 양이다')
-})
-
-test('재고가 있으면 복원된 오더가 실제로 이행된다 — 서 있기만 하면 의미가 없다', () => {
-  const { k } = seedKernel(
-    observed([{ id: 'SO-1', kind: 'outbound', status: 'in-progress', requested: 8, fulfilled: 0, lines: [{ gtin: GTIN, requested: 8, fulfilled: 0 }] }])
-  )
-  const fc = (k as any).fork()
-  for (let t = 0; t < 1200; t++) fc.tick(1000)
-  const o = fc.getSnapshot().orders.find((x: any) => x.id === 'SO-1')
-  assert.ok(o, '예측에도 오더가 있어야 한다')
-  assert.ok(o.progress > 0, `복원된 오더가 진행돼야 한다(progress=${o.progress})`)
-})
-
-test('이미 이행된 오더는 서지 않는다 — 다 끝난 일을 다시 계획하지 않는다', () => {
-  const { k, plan } = seedKernel(
-    observed([{ id: 'SO-DONE', kind: 'outbound', status: 'completed', requested: 10, fulfilled: 10, lines: [{ gtin: GTIN, requested: 10, fulfilled: 10 }] }])
-  )
-  assert.equal(plan.orderCount, 1, '판정은 원값이 있으므로 넘긴다')
-  assert.equal((k as any).orders.get('SO-DONE'), undefined, '커널이 남은 양 0 으로 보고 세우지 않는다')
-})
-
-test('원값이 없는 오더는 커널에 서지 않고, 몇 건인지 남는다', () => {
-  const state = observed([{ id: 'SO-P', kind: 'outbound', status: 'in-progress', progress: 0.5 }])
-  const plan = planWarmStart(state, undefined, true)
-  assert.equal(plan.action, 'hydrate')
-  if (plan.action !== 'hydrate') return
-  assert.equal(plan.orderCount, 0)
-  assert.equal(plan.ordersWithoutDemand, 1, '뺀 사실이 숫자로 남아야 로그가 말할 수 있다')
-
-  const k = new WmsKernel('t')
-  k.loadTwinModel(model() as any)
-  ;(k as any).hydrateObserved(plan.seed)
-  assert.equal((k as any).orders.size, 0, 'progress 만으로는 남은 양을 알 수 없으므로 지어내지 않는다')
-})
-
-test('재고도 함께 살아난다 — 오더를 넣다가 기존 복원을 깨지 않았는지', () => {
-  const { k } = seedKernel(observed([{ id: 'SO-1', requested: 5, fulfilled: 0, kind: 'outbound', status: 'in-progress' }]))
-  const snap = (k as any).getSnapshot()
-  assert.equal(snap.items.length, 20, '재고 20건이 그대로 복원돼야 한다')
-  assert.equal(snap.equipment.length, 2)
-})
-
-test('라이브 상태의 확인 처리가 신호에 반영된다 — 라이브에서는 전혀 반영되지 않던 것', () => {
-  /*
-   * `withLiveAttentions` 가 확인 목록을 넘기지 않아, 라이브(미러)에서는 사람이 확인해도 신호가
-   * 계속 활성으로 나갔다. 저널에서 되살린 확인 처리가 여기까지 닿는지 본다.
-   */
-  const state = {
-    locations: [{ id: 'bin-tight', type: 'storage', capacity: 1, occupancy: 1 }],
-    equipment: [],
-    orders: [],
-    tasks: [],
-    acked: [] as string[]
-  }
-  const before = withLiveAttentions(state).attentions ?? []
-  const signal = before[0]
-  assert.ok(signal, '픽스처 전제 — 병목 신호가 서야 한다')
-  /* 확인 전에는 `state` 를 채우지 않는다(확인된 것만 표시한다) — 없음과 'acknowledged' 를 가른다. */
-  assert.notEqual(signal.state, 'acknowledged', '확인하지 않았는데 확인된 것으로 나오면 안 된다')
-
-  const after = withLiveAttentions({ ...state, acked: [signal.id] }).attentions ?? []
-  assert.equal(after.find((a: any) => a.id === signal.id)?.state, 'acknowledged', '확인 처리가 라이브 신호에 반영돼야 한다')
-})
-
-/*
- * ★ Folded orders survive a restart (ADR-0092). Their counts are the only record of the finished orders
- * taken out of the hot list, and the seed used to leave them out — a restart after a fold lost them all.
- */
-test('the folded side comes back with the twin — nothing re-sends those counts', () => {
-  const foldedOrders = { counts: { outbound: { shipped: 40, cancelled: 2 }, inbound: { completed: 55 } }, boundaryMs: 1_700_000_000_000 }
-  const { k, plan } = seedKernel({ ...observed([]), foldedOrders } as any)
-  assert.equal(plan.foldedOrderCount, 97)
-  assert.deepEqual((k as any).getSnapshot().foldedOrders?.counts, foldedOrders.counts)
-})
-
-test('a value without counts is not a folded side, and a twin that folded nothing carries none', () => {
-  const junk = planWarmStart({ ...observed([]), foldedOrders: { boundaryMs: 1 } } as any, undefined, true)
-  assert.equal(junk.action === 'hydrate' && 'foldedOrders' in junk.seed, false)
-  const none = planWarmStart(observed([]), undefined, true)
-  assert.equal(none.action === 'hydrate' && none.foldedOrderCount, 0)
-})