@things-factory/headless-twin 10.1.278 → 10.1.280

package/test/actuation-settle.test.ts

@@ -1,164 +0,0 @@
-/*
- * **폐루프의 배선** — 관측이 들어올 때 나간 지시와 실제로 이어지는가.
- *
- * 판정은 `actuation-effect.test.ts` 가 지킨다. 여기서 보는 것은 **그 판정이 유입 경로에 서 있는가**다
- * — 봉투에서 오더 보고를 골라내는가, 저장소에 적히는가, 실패해도 관측 유입이 멈추지 않는가.
- *
- * 마지막 것이 특히 중요하다. 효과를 적다 실패해서 유입이 멈추면 **고치는 동안 트윈이 눈을 감는다.**
- * 효과는 다음 보고에 다시 이을 수 있고 관측은 다시 오지 않는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { OP_EVENT } from '@operato/ops-contract'
-
-import type { CommandStore, StoredCommand } from '../server/service/actuation/command-dispatcher.js'
-import { orderObservationsIn, settleEffects } from '../server/service/actuation/settle-effects.js'
-
-const DOMAIN = 'd-1'
-const AT = '2026-09-02T09:00:00.000Z'
-
-/**
- * 실측한 봉투 모양 그대로 — 훅과 라이브가 같은 것을 낸다.
- *
- * `data` 를 따로 뺀다. 처음에 `...over` 를 뒤에 두었더니 병합한 `data` 를 통째로 덮어써서 `orderId`
- * 가 사라졌고, **시험이 이을 것이 없는 봉투로 판정을 부르고 있었다.**
- */
-const orderEnv = ({ data, ...over }: Record<string, any> = {}) => ({
-  eventId: `e-${Math.random()}`,
-  eventType: OP_EVENT.order,
-  eventTime: AT,
-  tenantId: DOMAIN,
-  ...over,
-  data: { orderId: 'WO-20260902-005', kind: 'workorder', status: 'released', ...(data ?? {}) }
-})
-
-const otherEnv = () => ({ eventId: 'x', eventType: OP_EVENT.equipment, eventTime: AT, tenantId: DOMAIN, data: {} })
-
-function makeStore(seed: Partial<StoredCommand>[] = []) {
-  const rows = seed.map(c => ({ id: 'cmd-1', instanceId: 'twin-a', type: 'production.order', state: 'acked', ...c }) as any)
-  const written: any[] = []
-  const store: CommandStore & { written: any[]; queries: string[][] } = {
-    written,
-    queries: [],
-    load: async () => null,
-    save: async () => {},
-    create: async (_d, c) => c,
-    byDispatchRef: async (_d, refs) => {
-      store.queries.push([...refs])
-      return new Map(rows.filter(r => r.dispatchRef && refs.includes(r.dispatchRef)).map(r => [r.dispatchRef, r]))
-    },
-    recordEffects: async (_d, updates) => void written.push(...updates)
-  }
-  return store
-}
-
-/* ── 봉투에서 골라낸다 ──────────────────────────────────────────────────────── */
-
-test('★ 오더 보고만 골라낸다 — 다른 어휘를 오더로 읽지 않는다', () => {
-  const out = orderObservationsIn([orderEnv(), otherEnv(), orderEnv({ data: { orderId: 'WO-2' } })])
-
-  assert.equal(out.length, 2)
-  assert.deepEqual(out.map(o => o.orderId).sort(), ['WO-2', 'WO-20260902-005'])
-})
-
-test('★ 시각은 봉투의 것을 쓴다 — 우리가 처리한 시각이 아니다', () => {
-  const out = orderObservationsIn([orderEnv({ eventTime: '2026-08-31T01:02:03.000Z' })])
-
-  assert.equal(out[0]!.at, '2026-08-31T01:02:03.000Z')
-})
-
-test('식별자 없는 보고는 골라내지 않는다 — 이을 수 없는 것을 판정에 넘기지 않는다', () => {
-  assert.deepEqual(orderObservationsIn([orderEnv({ data: { orderId: '' } })]), [])
-})
-
-test('봉투가 없어도 터지지 않는다 — 유입 경로에서 부른다', () => {
-  assert.deepEqual(orderObservationsIn(undefined as any), [])
-  assert.deepEqual(orderObservationsIn([null, undefined] as any), [])
-})
-
-/* ── 실제로 적힌다 ─────────────────────────────────────────────────────────── */
-
-test('★ 우리가 낸 지시의 보고가 저장소에 적힌다 — 이것이 폐루프가 닫히는 순간이다', async () => {
-  const store = makeStore([{ id: 'cmd-1', dispatchRef: 'WO-20260902-005' }])
-  const out = await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv()], store })
-
-  assert.equal(out.recorded, 1)
-  assert.deepEqual(store.written, [{ commandId: 'cmd-1', status: 'released', at: AT, seen: 1 }])
-})
-
-test('★ 오더 보고가 없는 묶음은 저장소를 건드리지 않는다 — 유입은 초당 수천 건이 지난다', async () => {
-  const store = makeStore([{ dispatchRef: 'WO-20260902-005' }])
-  const out = await settleEffects({ domainId: DOMAIN, envelopes: [otherEnv(), otherEnv()], store })
-
-  assert.deepEqual(store.queries, [], '오더가 없는데 저장소에 물었다')
-  assert.equal(out.recorded, 0)
-})
-
-test('★ 찾아볼 식별자만 묶어서 한 번 묻는다', async () => {
-  const store = makeStore([{ dispatchRef: 'WO-1' }])
-  await settleEffects({
-    domainId: DOMAIN,
-    envelopes: [orderEnv({ data: { orderId: 'WO-1' } }), orderEnv({ data: { orderId: 'WO-1' } }), orderEnv({ data: { orderId: 'WO-2' } })],
-    store
-  })
-
-  assert.equal(store.queries.length, 1, '보고마다 질의를 붙였다')
-  assert.deepEqual(store.queries[0]!.sort(), ['WO-1', 'WO-2'])
-})
-
-test('우리가 내지 않은 오더만 온 묶음은 아무것도 적지 않는다', async () => {
-  const store = makeStore([{ dispatchRef: 'WO-우리것' }])
-  const out = await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv({ data: { orderId: 'WO-남의것' } })], store })
-
-  assert.deepEqual(store.written, [])
-  assert.equal(out.unmatched, 1)
-})
-
-test('★ 이미 적힌 효과에서 이어 센다 — 저장소가 든 값을 판정에 넘긴다', async () => {
-  const store = makeStore([
-    { id: 'cmd-1', dispatchRef: 'WO-20260902-005', effect: { status: 'released', at: AT, seen: 2 } }
-  ])
-  await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv({ data: { status: 'in-progress' } })], store })
-
-  assert.equal(store.written[0]!.seen, 3)
-})
-
-/* ── 관측 유입을 멈추지 않는다 ─────────────────────────────────────────────── */
-
-test('★ 저장소가 터져도 던지지 않는다 — 고치는 동안 트윈이 눈을 감으면 안 된다', async () => {
-  const store = makeStore([{ dispatchRef: 'WO-20260902-005' }])
-  store.byDispatchRef = async () => {
-    throw new Error('연결이 끊겼다')
-  }
-
-  const out = await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv()], store })
-  assert.deepEqual(out, { recorded: 0, unmatched: 0 })
-})
-
-test('★ 적다가 터져도 던지지 않는다', async () => {
-  const store = makeStore([{ dispatchRef: 'WO-20260902-005' }])
-  store.recordEffects = async () => {
-    throw new Error('쓰다 실패했다')
-  }
-
-  const out = await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv()], store })
-  assert.deepEqual(out, { recorded: 0, unmatched: 0 })
-})
-
-test('★ 저장소에 이을 자리가 없으면 조용히 지나지 않는다 — 영원히 모르는 상태가 된다', async () => {
-  const said: string[] = []
-  const warn = console.warn
-  console.warn = (...a: unknown[]) => void said.push(a.join(' '))
-
-  try {
-    const store = makeStore([{ dispatchRef: 'WO-20260902-005' }])
-    delete (store as any).byDispatchRef
-
-    const out = await settleEffects({ domainId: DOMAIN, envelopes: [orderEnv()], store })
-    assert.equal(out.recorded, 0)
-    assert.ok(said.join('\n').includes('byDispatchRef'), '무엇이 없어서인지 말하지 않았다')
-  } finally {
-    console.warn = warn
-  }
-})

package/test/actuation-target.test.ts

@@ -1,145 +0,0 @@
-/*
- * **승인된 조치를 어디로 보낼 수 있나** — 그 판정.
- *
- * 이 판정이 없어서 실제로 끊겨 있었다. 넘기는 리졸버가 어댑터를 찾지도 않고 「구현이 없습니다」를
- * 답했고, MES 커넥터는 그때 이미 `actuate` 를 다 만들어 두었다. 답이 그럴듯해서 설계 문서에도 다른
- * 레인에도 그대로 옮겼다.
- *
- * 그래서 여기서 지키는 것은 둘이다 — **보낼 수 있으면 보내는가**, 그리고 **못 보낼 때 무엇이 없어서
- * 인지 말하는가.** 뒤엣것이 없으면 사람은 커넥터를 다시 만들려 든다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { actuationTarget, isActuationAllowed, type ActuationTargetInput } from '../server/service/reference/actuation-target.js'
-
-const input = (over: Partial<ActuationTargetInput> = {}): ActuationTargetInput => ({
-  instanceId: 'twin-a',
-  twinExists: true,
-  siteId: 'plant-a',
-  ref: { source: 'twin-a', adapterType: 'operato-plant' },
-  adapterRegistered: true,
-  capabilities: ['live', 'actuate'],
-  declaresActuate: true,
-  hasActuateImpl: true,
-  ...over
-})
-
-/** 거절 코드를 꺼낸다 — 통과했으면 시험을 세운다(캐스팅으로 덮지 않는다). */
-function refusalOf(t: ReturnType<typeof actuationTarget>): string {
-  assert.equal(isActuationAllowed(t), false, '거절해야 하는데 통과했다')
-  return (t as any).code
-}
-
-/* ── 보낼 수 있으면 어디로까지 답한다 ───────────────────────────────────────── */
-
-test('★ 선언과 구현이 다 있으면 보낼 수 있다 — 어디로까지 답한다', () => {
-  const t = actuationTarget(input())
-
-  assert.equal(isActuationAllowed(t), true)
-  assert.deepEqual(t, { ok: true, siteId: 'plant-a', adapterType: 'operato-plant', source: 'twin-a' })
-})
-
-test('사이트 이름의 앞뒤 공백은 다듬는다 — 주소에 그대로 들어가는 값이다', () => {
-  const t = actuationTarget(input({ siteId: '  plant-a  ' }))
-  assert.equal((t as any).siteId, 'plant-a')
-})
-
-/* ── 구현만 있고 선언이 없는 경우를 따로 말한다 ────────────────────────────── */
-
-test('★ 구현은 있는데 선언이 없으면 그렇게 말한다 — 커넥터를 다시 만들게 하지 않는다', () => {
-  /*
-   * 실제로 있던 상태다. `operato-plant` 가 `actuate` 를 만들어 두고 `capabilities: ['live','control']` 만
-   * 선언했다. 「이 원본은 조치를 받지 않습니다」로 뭉개면 고칠 한 줄을 못 찾는다.
-   */
-  const t = actuationTarget(input({ capabilities: ['live', 'control'], declaresActuate: false, hasActuateImpl: true }))
-
-  assert.equal(refusalOf(t), 'not-declared')
-  assert.match((t as any).detail, /capabilities/, '무엇을 고쳐야 하는지 말하지 않는다')
-})
-
-test('★ 구현도 선언도 없으면 다른 코드로 말한다 — 고칠 것이 다르다', () => {
-  const t = actuationTarget(input({ capabilities: ['live'], declaresActuate: false, hasActuateImpl: false }))
-
-  assert.equal(refusalOf(t), 'not-supported')
-  assert.match((t as any).detail, /관측만/)
-})
-
-test('★ 선언은 있는데 구현이 없으면 「관측만 냅니다」가 아니다 — 그 사람은 조치를 하겠다고 적었다', () => {
-  /*
-   * 만들다 만 커넥터다. 등록 검사는 이쪽을 **말하지 않는다** — 구현했는데 선언 안 한 반대 방향만 본다.
-   * 그러니 이 자리가 말하지 않으면 아무도 말하지 않고, 사람은 자기가 적어 둔 선언을 믿고 조치가 되는
-   * 줄로 읽는다.
-   */
-  const t = actuationTarget(input({ capabilities: ['live'], declaresActuate: true, hasActuateImpl: false }))
-
-  assert.equal(refusalOf(t), 'not-implemented')
-  assert.doesNotMatch((t as any).detail, /관측만/, '선언한 사람에게 「관측만 냅니다」라고 답했다')
-  assert.match((t as any).detail, /actuate/, '무엇을 만들어야 하는지 말하지 않는다')
-})
-
-test('낼 수 있나는 능력 판정만 본다 — 선언·구현 두 값은 이유를 말하기 위한 것이다', () => {
-  /*
-   * `capabilitiesOf` 가 선언과 구현을 함께 보고 답한 값이 판정의 근거다. 여기서 두 값으로 다시
-   * 판단하면 규칙이 두 벌이 되고, 한쪽만 고쳐지는 날이 온다.
-   */
-  const t = actuationTarget(input({ capabilities: ['actuate'], declaresActuate: false, hasActuateImpl: false }))
-  assert.equal(isActuationAllowed(t), true, '능력 판정의 결과를 신뢰하지 않고 여기서 다시 판단했다')
-})
-
-/* ── 모르면 보내지 않는다 ───────────────────────────────────────────────────── */
-
-test('★ 어느 사이트에서 왔는지 모르면 보내지 않는다 — 첫 번째 사이트로 보내지 않는다', () => {
-  /*
-   * 원본 하나가 여러 사이트를 낸다. 모르는 채로 아무 데나 보내면 **잘못된 공장이 실제로 만든다.**
-   * 구동(control)은 사이트를 몰라도 넘기지만 이쪽은 다르다.
-   */
-  assert.equal(refusalOf(actuationTarget(input({ siteId: undefined }))), 'no-site')
-  assert.equal(refusalOf(actuationTarget(input({ siteId: '   ' }))), 'no-site', '공백을 사이트 이름으로 읽었다')
-})
-
-test('★ 원본이 없는 트윈에는 보내지 않는다 — 시뮬레이션으로만 세운 트윈이다', () => {
-  assert.equal(refusalOf(actuationTarget(input({ ref: undefined }))), 'no-source')
-})
-
-test('★ 거절 문장이 어느 트윈인지 말한다 — 「모르는 트윈입니다」만으로는 찾을 수 없다', () => {
-  for (const over of [{ twinExists: false, ref: undefined }, { ref: undefined }, { siteId: undefined }]) {
-    const t = actuationTarget(input(over)) as any
-    assert.match(t.detail, /twin-a/, `${t.code} 가 어느 트윈인지 말하지 않는다`)
-  }
-})
-
-test('모르는 트윈은 원본을 묻기 전에 거절한다', () => {
-  assert.equal(refusalOf(actuationTarget(input({ twinExists: false, ref: undefined }))), 'unknown-twin')
-})
-
-test('등록되지 않은 커넥터는 능력을 묻기 전에 거절한다 — 물을 데가 없다', () => {
-  const t = actuationTarget(input({ adapterRegistered: false, capabilities: [], hasActuateImpl: false }))
-
-  assert.equal(refusalOf(t), 'no-adapter')
-  assert.match((t as any).detail, /operato-plant/, '어느 커넥터인지 말하지 않으면 찾을 수 없다')
-})
-
-/* ── 거절은 전부 코드를 갖는다 ──────────────────────────────────────────────── */
-
-test('★ 모든 거절에 코드와 문장이 함께 있다 — 화면이 다음 할 일을 가를 수 있게', () => {
-  const cases: Partial<ActuationTargetInput>[] = [
-    { twinExists: false },
-    { ref: undefined },
-    { adapterRegistered: false, capabilities: [], declaresActuate: false, hasActuateImpl: false },
-    { capabilities: ['live', 'control'], declaresActuate: false, hasActuateImpl: true },
-    { capabilities: ['live'], declaresActuate: true, hasActuateImpl: false },
-    { capabilities: ['live'], declaresActuate: false, hasActuateImpl: false },
-    { siteId: undefined }
-  ]
-
-  const codes = cases.map(over => {
-    const t = actuationTarget(input(over)) as any
-    assert.equal(t.ok, false)
-    assert.ok(t.code, '거절에 코드가 없다')
-    assert.ok(t.detail?.length > 10, '거절에 사람이 읽을 문장이 없다')
-    return t.code
-  })
-
-  assert.equal(new Set(codes).size, codes.length, '다른 원인이 같은 코드로 답했다 — 화면이 구별할 수 없다')
-})

package/test/actuation-verification-state.test.ts

@@ -1,139 +0,0 @@
-/*
- * ★ **한 번 넘겨 봤나** — 설정이 맞는 것과 저쪽이 받는 것은 다르다 (ADR-0046 ②).
- *
- * 주소도 비밀값도 다 적혀 있는데 저쪽 프로세스가 그 값을 잃은 일이 있었다(§`actuationReadiness`).
- * 그것은 넘겨 봐야만 알고, 그래서 「아직 안 해 봤다」와 「해 봤고 됐다」와 「해 봤고 안 됐다」가
- * 서로 다른 사실이다. 이 시험은 그 셋이 안 뭉개지는지 본다.
- *
- * ── 저장되는 것은 코드다 ────────────────────────────────────────────────────
- * `lastError` 가 사람 문장을 저장해 두고 화면이 그것을 그대로 뿌렸다. 번역도 집계도 안 되고,
- * 커넥터가 문장을 고치는 날 옛 행과 새 행이 다른 말을 한다. 그래서 사유는 코드로만 앉는다.
- */
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-
-import { actuationAddressed, actuationOutcomePatch, actuationResetPatch } from '../server/service/reference/actuation-verification.js'
-
-const AT = '2026-09-16T04:05:06.000Z'
-
-test('받아들여지면 verified 로 서고 그 시각이 남는다', () => {
-  const patch = actuationOutcomePatch({ ok: true, ref: 'JO-1' }, AT)
-
-  assert.equal(patch.actuationState, 'verified')
-  assert.equal(patch.actuationVerifiedAt, AT)
-})
-
-test('★ 받아들여지면 지난 거절을 지운다 — 「됐는데 실패 사유가 있다」를 그리지 않게', () => {
-  assert.equal(actuationOutcomePatch({ ok: true }, AT).actuationFailure, null)
-})
-
-test('★ 거절되면 사유가 코드로 앉는다 — 문장이 아니라', () => {
-  const patch = actuationOutcomePatch(
-    { ok: false, error: '저쪽이 503 을 답했습니다', errorCode: 'peer-unavailable', errorParams: { status: 503 } },
-    AT
-  )
-
-  assert.equal(patch.actuationState, 'failed')
-  assert.deepEqual(patch.actuationFailure, { code: 'peer-unavailable', at: AT, params: { status: 503 } })
-
-  /* 사람 문장은 어디에도 안 실린다 — 그것이 이 칸을 만든 이유다. */
-  assert.ok(!JSON.stringify(patch).includes('503 을 답했습니다'))
-})
-
-test('★ 코드가 없으면 사유를 비운다 — 자리를 채우려고 문장을 옮기지 않는다', () => {
-  const patch = actuationOutcomePatch({ ok: false, error: '무언가 잘못됐습니다' }, AT)
-
-  assert.equal(patch.actuationState, 'failed', '코드가 없어도 실패는 실패다')
-  assert.equal(patch.actuationFailure, null, '모르는 것을 적었다')
-})
-
-test('★ 거절은 성공 시각을 지우지 않는다 — 「한 번이라도 닿은 적 있나」가 남아야 한다', () => {
-  const patch = actuationOutcomePatch({ ok: false, errorCode: 'peer-unavailable' }, AT)
-
-  assert.ok(!('actuationVerifiedAt' in patch), '실패가 지난 성공의 시각을 덮었다')
-})
-
-test('★ params 가 없으면 그 칸을 만들지 않는다 — 빈 객체와 「없다」는 다르다', () => {
-  const patch = actuationOutcomePatch({ ok: false, errorCode: 'not-declared' }, AT)
-
-  assert.deepEqual(patch.actuationFailure, { code: 'not-declared', at: AT })
-})
-
-/*
- * 위 시험들은 **판단만** 본다. 판단이 옳아도 아무도 안 부르면 레퍼런스에는 아무것도 안 남는다 —
- * 순수 시험은 부르는 사람을 못 본다.
- *
- * 값으로 재려면 DB 가 붙어야 해서, 여기서는 원문을 읽는다. 다만 **어느 함수 안에서 부르는지까지**
- * 본다. 파일 전체에서 이름을 세면 **선언이 자기를 센다** — 실제로 호출을 지우고 돌려 봤는데 이
- * 시험이 초록이었다. 세는 것은 주장이지 그 이웃이 아니다.
- */
-const strip = (x: string) => x.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/[^\n]*/g, '')
-const src = strip(readFileSync(new URL('../server/service/reference/actuation-routing.ts', import.meta.url), 'utf8'))
-const bodyOf = (name: string) => {
-  const at = src.indexOf(`function ${name}(`)
-  assert.ok(at > 0, `${name} 이 없다`)
-  const next = src.slice(at + 1).search(/\nasync function |\nexport (async )?function /)
-  return next < 0 ? src.slice(at) : src.slice(at, at + 1 + next)
-}
-
-test('★ routeActuation 이 실제로 그것을 부른다 — 판단만 맞고 아무도 안 부르면 남는 것이 없다', () => {
-  const route = bodyOf('routeActuation')
-
-  assert.match(route, /recordActuationOutcome\(/, '조치 경로에서 그 기록이 불리지 않는다')
-  /* 기록이 본업을 막지 않는다 — 실패해도 조치 결과는 그대로 돌아간다. */
-  assert.match(route, /\.catch\(/, '기록이 실패하면 조치까지 함께 넘어진다')
-  assert.match(route, /return result/, '조치 결과를 돌려주지 않는다')
-})
-
-test('★ 기록하는 자리가 판단을 쓰고 그 값을 저장한다 — 자기 판단을 다시 짓지 않는다', () => {
-  const record = bodyOf('recordActuationOutcome')
-
-  assert.match(record, /actuationOutcomePatch\(/, '판단을 부르지 않는다 — 두 벌이 된다')
-  assert.match(record, /\.update\(/, '부른 결과를 저장하지 않는다')
-})
-
-test('★ 주소를 바꾸는 저장은 검증을 되돌린다 — 지난 왕복은 지난 주소의 이야기다', () => {
-  /*
-   * 2026-09-18 실측(ADR-0046 ② 를 코드에 대어 본 결과): 칸 셋도 왕복의 결과를 적는 자리도 섰는데,
-   * `verified` 인 연결의 주소를 바꿔도 그대로 `verified` 였다. 화면은 다른 공장을 가리키는 연결을
-   * 「확인됨」으로 그린다.
-   */
-  const before = { intakeEndpoint: 'https://a.example/intake', intakeSiteId: 'line-a', intakeSecret: 's1' }
-  const moved = actuationResetPatch(before, { ...before, intakeEndpoint: 'https://b.example/intake' })
-  assert.deepEqual(moved, { actuationState: 'unverified', actuationVerifiedAt: null, actuationFailure: null })
-  assert.ok(actuationResetPatch(before, { ...before, intakeSiteId: 'line-b' }), '받는 사이트가 바뀌었다')
-  assert.ok(actuationResetPatch(before, { ...before, intakeSecret: 's2' }), '저쪽이 우리를 못 알아보면 그 왕복은 다시 성립하지 않는다')
-  assert.ok(actuationResetPatch(undefined, before), '처음 적는 주소도 아직 왕복이 없다')
-})
-
-test('주소가 그대로면 검증도 그대로 — 이름만 고쳤다고 되돌리지 않는다', () => {
-  const cfg = { intakeEndpoint: 'https://a.example/intake', intakeSiteId: 'line-a', intakeSecret: 's1' }
-  assert.equal(actuationResetPatch(cfg, { ...cfg, label: '군산 1라인' }), null)
-  /* 끝의 빗금은 같은 주소다 — 그것으로 되돌리면 저장할 때마다 초록이 사라진다. */
-  assert.equal(actuationResetPatch(cfg, { ...cfg, intakeEndpoint: 'https://a.example/intake/' }), null)
-  /* 가려진 비밀값은 저장 쪽이 병합해 옛 값 그대로 온다(그래서 여기까지 같은 값이 온다). */
-  assert.equal(actuationResetPatch(cfg, { ...cfg }), null)
-})
-
-test('★ 보낼 주소가 적힌 연결에만 검증 상태를 말한다 — 읽기만 하는 연결에 할 일을 만들지 않는다', () => {
-  assert.equal(actuationAddressed({ intakeEndpoint: 'https://a.example/intake', intakeSiteId: 'line-a' }), true)
-  assert.equal(actuationAddressed({ intakeEndpoint: 'https://a.example/intake', siteId: 'line-a' }), true, 'siteId 가 그 자리를 대신한다')
-  assert.equal(actuationAddressed({ intakeSiteId: 'line-a' }), false, '주소가 없으면 아무 데도 안 간다')
-  assert.equal(actuationAddressed({ intakeEndpoint: 'https://a.example/intake' }), false, '받는 사이트를 모르면 못 보낸다')
-  assert.equal(actuationAddressed(undefined), false)
-})
-
-test('★ 읽기 문이 그 상태를 싣는다 — 저장돼 있어도 나르지 않으면 화면이 볼 길이 없다', () => {
-  /*
-   * 2026-09-18 실측: 칸 셋은 2026-09 부터 서 있었고 왕복의 결과도 적히는데, 목록도 상세도 그 값을
-   * 싣지 않았다. 저장된 사실이 아무에게도 닿지 않는 상태였다.
-   */
-  const src = readFileSync(new URL('../server/service/reference/reference-resolver.ts', import.meta.url).pathname, 'utf-8')
-  for (const door of ['async twinReferences(', 'async twinReference(']) {
-    const at = src.indexOf(door)
-    assert.ok(at > 0, `${door} 를 못 찾았다 — 읽는 쪽이 깨졌다`)
-    const body = src.slice(at, at + 3000)
-    assert.ok(/actuationState/.test(body), `${door} 가 검증 상태를 싣지 않는다`)
-  }
-})

package/test/adopt-structure-live.test.ts

@@ -1,133 +0,0 @@
-/*
- * ★ 돌고 있는 미러에 새 구조를 넣는다 — **미러는 멈출 수 없다.**
- *
- * 미러가 비추는 현실은 24시간 돈다. 설비 한 대가 늘었다고 트윈을 멈췄다 세우면 그 사이의
- * 사실을 잃고, 라이브에서 유실은 곧 거짓이다. 그래서 미러는 **돌면서** 갈아탄다.
- *
- * 갈아타기가 옳으려면 **세 층이 함께** 움직여야 한다. 하나라도 빠지면 알리지 않고 어긋난다:
- *  ① 리비전 — 이후의 이벤트가 새 번호를 달고 다닌다(재생이 마디를 나눌 수 있게)
- *  ② 저장 model·구조 행 — 조회가 새 구조를 본다
- *  ③ 커널 — 지금 계산에 들어가는 이벤트가 새 구조 위에서 계산된다
- *
- * 커널 단위 거동(무엇을 지키고 무엇을 버리나)은 커널 쪽 `adopt-structure.test.ts` 가 지킨다.
- * 여기서 지키는 것은 **호스트 배선** — 세 층이 같은 인제스트에서 함께 움직이는가.
- *
- * 실 DataSource 로 돈다. 부분 적용은 정의상 "여러 표에 걸쳐 무엇이 남았나" 이므로.
- */
-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 { TwinStructure } = req('../dist-server/service/twin-structure/twin-structure.js')
-const { TwinLocation } = req('../dist-server/service/twin-model/twin-location.js')
-const { TwinEquipment } = req('../dist-server/service/twin-model/twin-equipment.js')
-const { DataSource: TypeOrmDataSource } = req('typeorm')
-
-let ds: DataSource
-let domainId: string
-
-const MIRROR = 'mirror-probe'
-const SIM = 'sim-probe'
-
-const master = (source: string, bins: number, forklifts: number): any => ({
-  source,
-  system: 'wms',
-  siteName: '미러 창고',
-  space: { width: 60, depth: 30, 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: Array.from({ length: forklifts }, (_, i) => ({ id: `fk-${i + 1}`, kind: 'forklift', homeLocationId: 'dock-recv' }))
-})
-
-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: 'adopt-test', subdomain: 'adopt-test' } as any)
-  domainId = d.id
-
-  await TwinEngine.ingestMaster(domainId, master(MIRROR, 3, 2), 'reset')
-  await TwinEngine.ingestMaster(domainId, master(SIM, 3, 2), 'reset')
-})
-
-after(async () => {
-  for (const id of [MIRROR, SIM]) await TwinEngine.stop(domainId, id).catch(() => {})
-  await ds?.destroy()
-})
-
-test('돌고 있는 미러는 멈추지 않고 갈아탄다 — 세 층이 함께 움직인다', async () => {
-  /* 미러 기동은 선언 기반 부팅이 가른다 — `startFromRegistry` 는 시뮬 경로다(같은 함수가 아니다). */
-  const rt = await TwinEngine.bootDeclared(domainId, MIRROR, 'resync')
-  assert.equal(rt.mode, 'live', '미러로 떠야 이 검사가 뜻이 있다')
-
-  const res = await TwinEngine.ingestMaster(domainId, master(MIRROR, 7, 2), 'reset')
-
-  /* ① 리비전 — 이후 이벤트가 달고 다닐 번호가 올라간다 */
-  const revs = await ds.getRepository(TwinStructure).find({ where: { instanceId: MIRROR }, order: { rev: 'ASC' } })
-  assert.deepEqual(revs.map((r: any) => r.rev), [1, 2], '구조가 달라졌으니 새 리비전이 남는다')
-
-  /* ② 저장 model·구조 행 — 조회가 새 구조를 본다 */
-  const inst = await ds.getRepository(TwinInstance).findOne({ where: { instanceId: MIRROR } })
-  assert.equal(inst.model.locations.length, 8, '저장 model 가 새 구조다(도크 1 + 빈 7)')
-  assert.equal(await ds.getRepository(TwinLocation).countBy({ instance: { id: inst.id } } as any), 8, '구조 행도 함께 다시 그려진다')
-
-  /* ③ 커널 — 멈추지 않은 채로 새 구조를 들고 있다 */
-  assert.equal(TwinEngine.instances[`${domainId}:${MIRROR}`]?.mode, 'live', '갈아타기가 미러를 멈추지 않는다')
-  const snap = TwinEngine.snapshot(domainId, MIRROR)
-  assert.equal(snap.locations.filter((n: any) => n.type === 'storage').length, 7, '커널도 새 자리를 들고 있다')
-
-  /* 무엇이 달라졌는지 **말한다** — 멈췄다 세우는 마디가 없으므로 말하지 않으면 알리지 않고 지나간다 */
-  const adopted = res.warnings.find((w: any) => w.code === 'structure-adopted')
-  assert.ok(adopted, '갈아타기는 말없이 성공하지 않는다')
-  assert.equal(adopted.params.locationsAdded, 4, '자리 4개가 늘었다(빈 3→7)')
-  assert.equal(adopted.params.rev, 2)
-})
-
-test('사라진 설비를 수로 알린다 — 자리가 수천인 현장에서 직접 세어 보게 하지 않는다', async () => {
-  const res = await TwinEngine.ingestMaster(domainId, master(MIRROR, 7, 1), 'reset') // 지게차 2 → 1
-  const adopted = res.warnings.find((w: any) => w.code === 'structure-adopted')
-  assert.equal(adopted.params.equipmentDropped, 1)
-
-  const inst = await ds.getRepository(TwinInstance).findOne({ where: { instanceId: MIRROR } })
-  assert.equal(await ds.getRepository(TwinEquipment).countBy({ instance: { id: inst.id } } as any), 1, '표에서도 사라진다')
-  assert.equal(TwinEngine.snapshot(domainId, MIRROR).equipment.length, 1, '커널에서도 사라진다')
-})
-
-test('돌고 있는 시뮬레이션은 여전히 거절한다 — 조건이 바뀐 실험은 다른 실험이다', async () => {
-  await TwinEngine.bootDeclared(domainId, SIM, 'reset')
-  const before = (await ds.getRepository(TwinStructure).find({ where: { instanceId: SIM } })).length
-
-  await assert.rejects(() => TwinEngine.ingestMaster(domainId, master(SIM, 9, 2), 'reset'), /is running/)
-
-  assert.equal(
-    (await ds.getRepository(TwinStructure).find({ where: { instanceId: SIM } })).length,
-    before,
-    '거절된 인제스트는 흔적을 남기지 않는다'
-  )
-})
-
-test('멈춘 미러는 구조를 전환하지 않는다 — 정지한 대상을 전환하려 하지 않는다', async () => {
-  await TwinEngine.stop(domainId, MIRROR)
-  await assert.rejects(
-    () => TwinEngine.adoptStructure(domainId, MIRROR, { locations: [], equipment: [] } as any),
-    /is not running/,
-    '멈춘 트윈은 프로비저닝으로 세우는 것이지 갈아타는 것이 아니다'
-  )
-})