@things-factory/headless-twin 10.1.277 → 10.1.279

package/package.json

@@ -1,12 +1,26 @@
 {
   "name": "@things-factory/headless-twin",
-  "version": "10.1.277",
+  "version": "10.1.279",
   "main": "dist-server/index.js",
   "exports": {
     ".": "./dist-server/index.js",
     "./log": "./dist-server/engine/log.js",
     "./*": "./*"
   },
+  "files": [
+    "README.md",
+    "dist-server",
+    "dist-shared",
+    "things-factory.config.js",
+    "!**/*.map",
+    "!**/*.test.*",
+    "!**/*.spec.*",
+    "!**/test/**",
+    "!**/tests/**",
+    "!**/__tests__/**",
+    "!**/*.tsbuildinfo",
+    "!**/.DS_Store"
+  ],
   "typesVersions": {
     "*": {
       "log": [
@@ -41,11 +55,11 @@
   "dependencies": {
     "@operato/ops-contract": "^0.9.40",
     "@operato/twin-kernel": "^0.11.29",
-    "@things-factory/auth-base": "^10.1.277",
-    "@things-factory/cache-service": "^10.1.277",
-    "@things-factory/env": "^10.1.149",
-    "@things-factory/ingest": "^10.1.277",
-    "@things-factory/shell": "^10.1.277"
+    "@things-factory/auth-base": "^10.1.279",
+    "@things-factory/cache-service": "^10.1.279",
+    "@things-factory/env": "^10.1.279",
+    "@things-factory/ingest": "^10.1.279",
+    "@things-factory/shell": "^10.1.279"
   },
-  "gitHead": "85f409e7ea43686a4cda52924247d9e7a6b0bfa7"
+  "gitHead": "666c08055c408b408fde961ad10da080941b147c"
 }

package/dist-server/engine/attention-digest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"attention-digest.js","sourceRoot":"","sources":["../../server/engine/attention-digest.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAuCH,4CAeC;AAqBD,kDAMC;AA/ED,uCAAuC;AACvC,MAAM,IAAI,GAA2B,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAA;AAyBhF,+CAA+C;AACxC,MAAM,iBAAiB,GAAG,CAAC,CAAgB,EAAE,CAAgB,EAAU,EAAE,CAC9E,CAAC,CAAC,CAAC,KAAK,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,CAAA;AAFlD,QAAA,iBAAiB,qBAEiC;AAE/D;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,UAAuD,EAAE,KAAc;IACtG,MAAM,GAAG,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAA;IAEvD,iDAAiD;IACjD,MAAM,kBAAkB,GAA2B,EAAE,CAAA;IACrD,KAAK,MAAM,CAAC,IAAI,GAAG,EAAE,CAAC;QACpB,MAAM,GAAG,GAAG,CAAC,EAAE,MAAM,EAAE,UAAU,CAAA;QACjC,IAAI,CAAC,GAAG;YAAE,SAAQ;QAClB,MAAM,GAAG,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAA;QACnC,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAAE,kBAAkB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,QAAQ,IAAI,EAAE,CAAA;IAC1G,CAAC;IAED,MAAM,MAAM,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,yBAAiB,CAAC,CAAA;IAC/C,MAAM,MAAM,GAAG,KAAK,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAA;IACnE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAA;AAC/E,CAAC;AAQD;;;;;;;;;;;;GAYG;AACH,SAAgB,mBAAmB,CAAC,MAAiC,EAAE,KAAc;IACnF,MAAM,GAAG,GAAoB,EAAE,CAAA;IAC/B,KAAK,MAAM,IAAI,IAAI,MAAM,EAAE,CAAC;QAC1B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,UAAU,IAAI,EAAE;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAmB,CAAC,CAAA;IACzG,CAAC;IACD,OAAO,gBAAgB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;AACrC,CAAC","sourcesContent":["/*\n * 주의 신호 요약 — **순수**. \"화면이 실제로 쓰는 두 가지만 값싸게 만든다.\"\n *\n * ── 왜 있나 (2026-08-05) ────────────────────────────────────────────────────\n * 축 선택으로 리프레시를 80KB → 2KB 로 줄였는데, **신호가 많은 트윈은 거기서 막혔다**: `hatio-yard`\n * 는 신호 397건이 108KB 라 5배 감소에 그쳤다. 그런데 화면이 그 397건으로 하는 일은 둘뿐이다.\n *\n *  ① 레일에 **20건**만 보여주고 나머지는 \"N건 더\" 라고만 말한다.\n *  ② 자리(폴리곤)를 칠할 **자리별 최고 심각도**를 뽑는다 — 397건이 자리 7곳의 색 7개로 줄어든다.\n *\n * 즉 전량을 내려보내 클라이언트가 계산하는 구조였다. 계산하는 것은 값싸므로 **서버가 계산해서 보낸다.**\n *\n * ── 알리지 않고 자르지 않는다 ────────────────────────────────────────────────────\n * 잘랐다는 사실과 **전체 개수**를 함께 보낸다. 경고 목록에서 들어온 것이 없는 누락은 \"괜찮은 줄 알았다\" 로\n * 이어진다 — 레일이 이미 \"N건 더\" 를 말하고 있었고, 그 N 은 전체 개수에서 나와야 맞다.\n *\n * ── 정렬을 한 곳에 둔다 ─────────────────────────────────────────────────────\n * 상위 N 을 서버가 고르므로 **클라이언트와 같은 순서**여야 한다. 순서가 다르면 서버가 고른 20건이\n * 화면이 고를 20건과 달라지고, 그 어긋남은 아무 데서도 오류로 드러나지 않는다.\n * 순서 = 확인된 것은 아래로, 그다음 심각도 높은 것부터(클라이언트 정렬과 동일).\n */\n\n/** 알람 표준(ISA-18.2) 우선순위 — 큰 값이 급하다. */\nconst RANK: Record<string, number> = { low: 1, medium: 2, high: 3, critical: 4 }\n\ninterface AttentionLike {\n  id?: string\n  /** 어느 트윈(렌즈)에서 온 신호인가 — 공간에서 모을 때 붙는다. */\n  instanceId?: string\n  severity?: string\n  state?: string\n  anchor?: { locationId?: string }\n}\n\nexport interface AttentionDigestResult {\n  /** 상위 N — 레일이 그리는 것. */\n  attentions: AttentionLike[]\n  /** 전체 개수 — 레일의 \"N건 더\" 가 이 값에서 나온다(자른 사실을 밝힌다). */\n  attentionTotal: number\n  /**\n   * 자리별 최고 심각도 — **전량을 근거로** 계산한다.\n   *\n   * 상위 N 만으로 계산하면 20위 밖의 신호를 가진 자리가 색을 잃는다. 그것이 이 요약의 핵심 이유다:\n   * 레일은 잘라도 되지만 **지도 색은 잘라선 안 된다.**\n   */\n  severityByLocation: Record<string, string>\n}\n\n/** 화면 정렬과 같은 순서 — 확인된 것은 아래로, 그다음 심각도 내림차순. */\nexport const compareAttentions = (a: AttentionLike, b: AttentionLike): number =>\n  (a.state === 'acknowledged' ? 1 : 0) - (b.state === 'acknowledged' ? 1 : 0) ||\n  (RANK[b.severity ?? ''] ?? 0) - (RANK[a.severity ?? ''] ?? 0)\n\n/**\n * 신호를 요약한다.\n *\n * `limit` 이 없거나 0 이하면 **자르지 않는다** — 자르는 쪽이 기본이면 이 값을 모르는 소비처가\n * 알리지 않고 일부만 받는다(요약을 도입하다 만드는 전형적인 사고다).\n */\nexport function digestAttentions(attentions: readonly AttentionLike[] | undefined | null, limit?: number): AttentionDigestResult {\n  const all = Array.isArray(attentions) ? attentions : []\n\n  /* 자리 색은 전량으로 처리한다 — 잘린 뒤에 계산하면 색을 잃는 자리가 생긴다. */\n  const severityByLocation: Record<string, string> = {}\n  for (const a of all) {\n    const nid = a?.anchor?.locationId\n    if (!nid) continue\n    const cur = severityByLocation[nid]\n    if (!cur || (RANK[a.severity ?? ''] ?? 0) > (RANK[cur] ?? 0)) severityByLocation[nid] = a.severity ?? ''\n  }\n\n  const sorted = [...all].sort(compareAttentions)\n  const capped = limit && limit > 0 ? sorted.slice(0, limit) : sorted\n  return { attentions: capped, attentionTotal: all.length, severityByLocation }\n}\n\n/** 렌즈 하나가 낸 신호 — 어느 트윈에서 왔는지와 함께. */\nexport interface LensAttentions {\n  instanceId: string\n  attentions: readonly AttentionLike[] | undefined | null\n}\n\n/**\n * 여러 렌즈의 신호를 **한 현장의 목록으로** 모은다.\n *\n * 한 공장에 WMS·MES·YMS 가 함께 있으므로 \"이 현장에서 봐야 할 것\" 은 렌즈 하나로 답할 수 없다.\n * 모으면서 지키는 것 셋:\n *\n *  ① **어느 트윈에서 왔는지 붙인다**(`instanceId`) — 조치는 결국 그 트윈에 보내야 하고, 공간에서 보면\n *     같은 자리 id 가 렌즈마다 다른 것을 가리킬 수 있다.\n *  ② **순서는 렌즈 순서가 아니라 급한 순서다** — 앞 렌즈의 낮은 신호가 뒤 렌즈의 심각한 신호를\n *     밀어내면, 상위 N 만 보는 화면에서 정작 급한 것이 안 보인다.\n *  ③ **자리 색은 렌즈를 가로질러 가장 급한 것으로** 계산한다 — 두 렌즈가 같은 자리를 가리키면 그 자리는\n *     하나의 현실이므로 더 급한 쪽이 이긴다(둘 중 하나를 임의로 고르면 색이 렌즈 순서에 따라 달라진다).\n */\nexport function mergeLensAttentions(lenses: readonly LensAttentions[], limit?: number): AttentionDigestResult {\n  const all: AttentionLike[] = []\n  for (const lens of lenses) {\n    for (const a of lens.attentions ?? []) all.push({ ...a, instanceId: lens.instanceId } as AttentionLike)\n  }\n  return digestAttentions(all, limit)\n}\n"]}

package/dist-server/engine/canonical-ingest.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"canonical-ingest.js","sourceRoot":"","sources":["../../server/engine/canonical-ingest.ts"],"names":[],"mappings":"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","sourcesContent":["import { type CanonicalRecord, type CanonicalAggregationRecord, type CanonicalTransformationRecord, type AdapterRule, type EnergyRecord, type EnergyEquipmentRecord, type EnergyGenerationRecord, type EnergyUsagePeriodRecord, type EnergyBillRecord, type EnergyTariffBasisRecord, type EnergyGenerationPriceRecord, type EnergyGenerationPeriodRecord, type OperationalRecord, type IngestResult, type MasterDataRecord } from '@operato/ops-contract'\nimport { ingest, ingestEnergyRecords, ingestEnergyEquipmentRecords, ingestEnergyGenerationRecords, ingestEnergyUsagePeriodRecords, ingestEnergyBillRecords, ingestEnergyTariffBasisRecords, ingestEnergyGenerationPriceRecords, ingestEnergyGenerationPeriodRecords, ingestOperationalRecords, isAggregationRecord, isTransformationRecord, isEnergyRecord, isEnergyEquipmentRecord, isEnergyGenerationRecord, isEnergyUsagePeriodRecord, isEnergyBillRecord, isEnergyTariffBasisRecord, isEnergyGenerationPriceRecord, isEnergyGenerationPeriodRecord, isOperationalRecord, isMasterDataRecord, ingestMasterData } from '@operato/ops-contract'\nimport { factEventTime, undatedByKind } from './event-time.js'\n\n/*\n * 정규 레코드 → 커널 검증 ACL → CanonicalEnvelope (P1 seam 코어).\n * 순수(커널만 의존; shell·integration-base 무의존 → node:test 검증 가능).\n * 매핑(레거시 스키마 → 정규)은 이 앞 단계(jsonata step 또는 커넥터 openLiveFeed)가 끝낸다.\n * 여기 도착하는 레코드는 이미 정규 필드다 — 어휘마다 자기 필드 이름이 계약이다:\n *   EPCIS 품목 { epc, action, bizStep, disposition?, readPoint?, bizLocation? }\n *   에너지 계량 { meterId, kW?, kWh?, … } · 설비 에너지 { equipmentId, generatedKW?, soc?, … }\n *   발전 적산   { equipmentId, kWh, kWhSince?, … }\n *   사용 구간   { meterId, from, to, kWh, unitPrice?, basis?, … }  · 청구서 { from, to, total?, … }\n *   요금 기준   { from, to, billingDemandKW?, demandChargePerKW?, currency }\n *   담김(적재) { parentID, childEPCs[] | childQuantityList[], action, bizStep, … }\n *   운영 사실 { taskId | moverId | personId | assetId | orderId, status, … }  // vocabulary-guard: allow 저널 와이어 필드\n * 커널은 objectEvent 구성 + EPCIS 검증(위반=오염 차단) + 봉투 래핑만(방언 없음).\n *\n * 두 소비처가 이 단일 코어를 공유(중복 금지):\n *   - sim/scenario 경로: operato-twin twin-ingest 태스크(http-get→jsonata→여기).\n *   - live 커넥터 경로: reference-live(어댑터 openLiveFeed→여기).\n * SoT: design/integration/face2-adapters.md §5(seam)·§7(매핑=밖, 검증=커널).\n */\n\n/*\n * **표준 헤더 필드는 한 번만 적는다** — 세 규칙이 이것을 펼쳐 쓴다.\n *\n * ── 왜 뽑아냈나 (2026-09-07) ────────────────────────────────────────────────\n * 이 파일은 규칙 셋을 손으로 나란히 적고 있었고, 그래서 헤더 필드를 더할 때마다 **세 곳을 다 고쳐야**\n * 했다. 그 구조가 같은 결함을 네 번 만들었다.\n *\n * ```\n * quantityList        낱개 번호 없는 자재의 잔량을 말할 길이 없었다\n * ilmd                포천 재고 1,704행 전부에 소비기한이 있는데 상태에는 0건\n * errorDeclaration    정정이 또 하나의 사실로 쌓였다\n * bizTransactionList  저널에 칸·인덱스·질의가 다 있는데 실 시스템 연결에서 0건\n * ```\n *\n * 네 번째는 계약을 열고도 **이 파일이 그 스펙을 안 써서** 여전히 사라지고 있었다. 인티그레이션 레인이\n * 규칙 그대로 `mapRecord` 를 돌려서 찾았다 — 읽어서 맞다고 하지 않고 돌려 본 것이 잡았다.\n *\n * 이제 헤더 필드를 더하는 것은 **이 상수 한 줄**이고, 세 갈래에 동시에 닿는다.\n *\n * `action` 은 여기 없다 — `TransformationEvent` 에는 그 칸이 없다(무엇이 무엇으로 되었나에는 방향이\n * 하나뿐이다). 그것만 규칙마다 적는다.\n */\nconst TWIN_INGEST_HEADER = {\n  bizStep: '$.bizStep',\n  disposition: '$.disposition',\n  /*\n   * **정정 선언** — 「이 사건은 없던 일이 되었다」(커널 0.7.65 에서 이 자리가 열렸다).\n   *\n   * 세 값이 함께여야 뜻이 있어 묶음으로 온다. 커널이 선언 시각을 요구하고, 없으면 사건 시각으로\n   * 메우지 않고 이유와 함께 돌려준다 — 「언제 정정했나」와 「언제 일어났나」가 같아지면 둘을 다시\n   * 갈라낼 수 없다.\n   *\n   * 상태는 이것으로 흔들리지 않는다. 커널은 정정을 목록에 적고 재고를 그대로 둔다 — 무엇을 어떻게\n   * 되돌릴지는 도메인 판단이고, 참 재고는 그 뒤의 잔량 관측이 다시 말해 준다.\n   */\n  errorDeclaration: {\n    declarationTime: '$.errorDeclaration.declarationTime',\n    reason: '$.errorDeclaration.reason',\n    correctiveEventIDs: '$.errorDeclaration.correctiveEventIDs'\n  },\n  /*\n   * **오더 참조** — 「이 물건은 어느 오더 것인가」(표준 §7.3.5.4, 계약 0.9.11 에서 이 자리가 열렸다).\n   *\n   * 받는 쪽은 처음부터 다 서 있었다: 저널에 `biz_transaction` 칸과 인덱스(`ix_twin_event_9`), 이력추적\n   * 질의가 그 칸으로 거르고, 커널이 네 자리에서 그것을 채운다. 그래서 커널 안쪽에서 나는 사실만 그\n   * 칸을 갖고 실 시스템이 먹이는 트윈은 조용히 비었다 — 시뮬 2,492건 대 `mes-line-a` 0건.\n   */\n  bizTransactionList: '$.bizTransactionList',\n  readPoint: '$.readPoint',\n  bizLocation: '$.bizLocation'\n} as const\n\n/** 고정 정규 매핑(방언 아님 — 필드명 자체가 정규 계약). `sourceType` 으로 어느 품목 사실인지 고른다. */\nconst TWIN_INGEST_RULES: AdapterRule[] = [\n  {\n    sourceType: 'twin',\n    mapping: {\n      type: 'ObjectEvent',\n      ...TWIN_INGEST_HEADER,\n      action: '$.action',\n      epc: '$.epc',\n      /* 비직렬 수량 — 개체 없이 「이 자리에 이 품목이 얼마 남았다」만 오는 관측이 있다. */\n      quantityList: '$.quantityList',\n      /*\n       * **개체·로트의 마스터데이터**(로트 번호·소비기한 등) — 커널 0.7.58 에서 이 자리가 열렸다.\n       *\n       * 실측(포천): 원본 재고 1,704행 **전부**에 소비기한이 있는데 투영된 상태에는 **0건**이었다. 지난\n       * 재고 950건·59,785kg 이 어디에도 나타나지 않았고, 빈 화면이 「이상 없음」으로 읽혔다.\n       *\n       * ★ **표준이 `action: 'ADD'` 일 때만 허용한다**(또는 변환). 마스터데이터는 로트가 **생길 때**\n       * 말하는 사실이고, 주기 관측마다 실으면 커널이 거부한다 — 알리지 않고 통과시키지 않는 것이 옳다\n       * (커넥터가 첫 목격에 `ADD`, 그 뒤로 `OBSERVE` 를 내야 한다).\n       */\n      ilmd: '$.ilmd',\n      /*\n       * **정정 선언** — 「이 사건은 없던 일이 되었다」(커널 0.7.65 에서 이 자리가 열렸다).\n       *\n       * 세 값이 함께여야 뜻이 있어 묶음으로 온다. 커널이 선언 시각을 요구하고, 없으면 사건 시각으로\n       * 메우지 않고 이유와 함께 돌려준다 — 「언제 정정했나」와 「언제 일어났나」가 같아지면 둘을 다시\n       * 갈라낼 수 없다.\n       *\n       * 상태는 이것으로 흔들리지 않는다. 커널은 정정을 목록에 적고 재고를 그대로 둔다 — 무엇을 어떻게\n       * 되돌릴지는 도메인 판단이고, 참 재고는 그 뒤의 잔량 관측이 다시 말해 준다.\n       */\n    }\n  },\n  {\n    /* **변환의 사실** — 무엇으로 무엇이 되었나. 이름은 표준의 것을 그대로 쓴다(갈래 판정이 그 이름을 본다). */\n    sourceType: 'twin-transformation',\n    mapping: {\n      type: 'TransformationEvent',\n      ...TWIN_INGEST_HEADER,\n      inputEPCList: '$.inputEPCList',\n      inputQuantityList: '$.inputQuantityList',\n      outputEPCList: '$.outputEPCList',\n      outputQuantityList: '$.outputQuantityList',\n      transformationID: '$.transformationID',\n    }\n  },\n  {\n    /*\n     * **담김의 사실** — 무엇이 무엇에 실렸나(팔레트·상자). 오래 비어 있던 자리다: 관측 리듀서는 이 사실을\n     * 받으면 자식 물품에 `parent` 를 붙이는데, 문이 `ObjectEvent` 하나만 알아서 원본은 적재를 말할 길이\n     * 없었다(시뮬 원본을 붙여 돌려 보고서야 로그로 드러났다).\n     */\n    sourceType: 'twin-aggregation',\n    mapping: {\n      type: 'AggregationEvent',\n      ...TWIN_INGEST_HEADER,\n      action: '$.action',\n      parentID: '$.parentID',\n      childEPCs: '$.childEPCs',\n      /* 낱개 식별자 없이 **수량으로** 담긴 자식(「이 품번 40개」) — 입고·포장이 이 모양으로 온다. */\n      childQuantityList: '$.childQuantityList',\n    }\n  }\n]\n\n/*\n * 규칙을 시험이 돌릴 수 있게 낸다 — **읽어서 맞다고 하지 않기 위해.**\n *\n * 오늘 이 자리가 정확히 그것으로 새고 있었다: 계약을 열고 계약 시험을 초록으로 만든 뒤에도, 이 파일이\n * 그 스펙을 안 써서 값이 계속 사라졌다. 인티그레이션 레인이 이 규칙 그대로 `mapRecord` 를 돌려 봐서\n * 찾았다 — 규칙이 파일 안에 갇혀 있으면 그것을 돌려 볼 방법이 없다.\n *\n * 복사본을 낸다. 부르는 쪽이 고쳐도 유입 경로가 바뀌지 않아야 한다.\n */\nexport function canonicalRulesForTest(): AdapterRule[] {\n  return TWIN_INGEST_RULES.map(r => ({ ...r, mapping: { ...r.mapping } }))\n}\n\n/*\n * 정규 레코드 셋(`CanonicalRecord` · `CanonicalTransformationRecord` · `CanonicalAggregationRecord`)은\n * **계약으로 옮겼다**(2026-08-30, `@operato/ops-contract` 0.2.0).\n *\n * 여기 있던 이유는 소비 방식 때문이었다 — EPCIS 는 커널의 범용 어댑터를 지나서 타입을 요구하지 않았다.\n * 그런데 모양 자체는 EPCIS 2.0 의 필드 이름이고 호스트의 것이 아니다. 이제 MES 가 이 모양 그대로\n * 보낸다.\n *\n * **매핑 룰(`TWIN_INGEST_RULES`)은 여기 남는다** — 이 모양을 EPCIS 사건으로 옮기는 정책이지 모양이 아니다.\n */\n\n/**\n * 거절 목록의 사본을 원본 참조로 되돌린다 — **훅이 객체 동일성으로 봉투와 짝짓기 때문이다.**\n *\n * 지도에 없는 것은 그대로 둔다. 사본을 만들지 않는 갈래(에너지·운영·어휘)의 거절이 그렇고, 그것들은\n * 이미 원본을 들고 있다.\n */\nfunction toOriginals(\n  originalOf: Map<unknown, unknown>,\n  rejected: { record: unknown; errors: string[] }[]\n): { record: unknown; errors: string[] }[] {\n  if (!originalOf.size) return rejected\n  return rejected.map(r => {\n    const original = originalOf.get(r.record)\n    return original === undefined ? r : { record: original, errors: r.errors }\n  })\n}\n\n/** 정규 레코드[] → 검증된 CanonicalEnvelope[] (+ 거부분). 순수 함수. 단일→객체도 배열로 정규화. */\nexport function ingestCanonicalRecords(\n  records:\n    | CanonicalRecord\n    | CanonicalAggregationRecord\n    | CanonicalTransformationRecord\n    | EnergyRecord\n    | EnergyEquipmentRecord\n    | OperationalRecord\n    /* 다섯째 어휘 — 사건이 아닌 것(변하지 않는 속성). 저널로 가지 않는다(§`CanonicalIngestResult`). */\n    | MasterDataRecord\n    | (\n        | CanonicalRecord\n        | CanonicalAggregationRecord\n        | CanonicalTransformationRecord\n        | EnergyRecord\n        | EnergyEquipmentRecord\n        | OperationalRecord\n        | MasterDataRecord\n      )[]\n    | undefined\n    | null,\n  tenantId: string,\n  defaultEventTime: string,\n  /**\n   * **이 사실들이 어느 트윈의 것인가** — 마감된 구간 사실의 이름에 쓰인다(커널 §`SubjectBasis`).\n   *\n   * 커널은 도메인으로 서므로 자기가 어느 트윈인지 모른다. 그런데 설비 번호·계량 지점 번호는 트윈\n   * 안에서만 통하는 이름표라, 한 도메인에 현장이 둘이면 서로 다른 설비의 같은 날이 한 사실이 된다.\n   * 실측으로 그 일이 났다 — 두 발전소의 `002` 가 겹쳤다.\n   *\n   * 주지 않으면 이름표를 그대로 쓰고 `twin-local` 로 표시된다 — 겹칠 수 있다는 뜻이다.\n   */\n  scope?: { scopeId?: string; identityOf?: (kind: 'equipment' | 'meter', localId: string) => string | undefined }\n): CanonicalIngestResult {\n  const arr = Array.isArray(records) ? records : records ? [records] : []\n\n  /*\n   * ── 사본을 만들었으면 나가는 길에 되돌린다 (2026-09-08 실측) ─────────────────\n   *\n   * 아래에서 레코드마다 `{ ...r, eventTime, sourceType }` 로 **새 객체**를 만들어 계약의 유입\n   * 함수에 넘긴다. 그 함수들은 거절한 것을 `{ record, errors }` 로 내는데, 그 `record` 는 **사본**이다.\n   *\n   * 훅은 거절된 레코드를 봉투와 짝지어 `eventId` 를 실어 보낸다(§`rejectedForCaller`). 그 짝은\n   * **객체 동일성**으로 짓는다 — 값으로 비교하면 같은 모양의 레코드 둘이 서로의 id 를 가져가기\n   * 때문이다. 그런데 사본은 원본과 다른 객체라 그 지도에 없고, 결과가 이렇게 나왔다.\n   *\n   * ```\n   * 보낸 것   {\"eventId\":\"probe-eventid-check-001\", \"record\":{\"kind\":\"transformation\"}}\n   * 온 것     rejected: [{ record: {kind:\"transformation\", sourceType:\"twin\"}, errors:[…] }]\n   *                      ↑ eventId 가 없다. 보내는 쪽이 어느 행이 떨어졌는지 모른다\n   * ```\n   *\n   * 보내는 쪽은 그래서 정산을 못 하고 큐가 안 움직인다(plant 실측: `PENDING 719`). 사실은 하나도\n   * 안 잃지만 나아가지도 않는다.\n   *\n   * **사본을 만든 자리가 되돌린다.** 훅이 값 비교로 내려가면 오늘 그 짝짓기를 객체 동일성으로 고른\n   * 이유가 없어지고, 계약의 유입 함수들이 원본을 들고 있게 바꾸면 그쪽이 사본을 만들 자유를 잃는다.\n   *\n   * 그리고 이 결함이 시험에 안 걸린 이유를 적어 둔다 — `hook-rejected-shape.test.ts` 가\n   * `rejectedForCaller` 에 **양쪽 다 같은 객체**를 직접 넘긴다. 순수 시험은 그 사이에 누가 사본을\n   * 만드는지 보지 않는다.\n   */\n  const originalOf = new Map<unknown, unknown>()\n  /*\n   * ── **다섯째 어휘는 사건이 아니다** (2026-08-28) ────────────────────────────\n   *\n   * 마스터데이터 — 변하지 않는 속성(유통기한·로트번호·자리의 성질). 표준은 이것을 사건이 아니라\n   * **어휘 요소의 속성**으로 담고, 커널에 그 자리가 없어서 지금까지 사건에 실려 왔다.\n   *\n   * 그 결과가 유입에서 이렇게 났다. 전량을 읽는 원본이 유통기한을 실으려고 **들어오지 않은 것을\n   * `ADD`** 라고 말했고, `ilmd` 가 사건 단위라 자리별로 묶을 수도 없어 낱개로 나갔다 — 재기동 한 번에\n   * 2,665건이다.\n   *\n   * 그래서 여기서 갈라 낸다. 이것은 봉투가 되지 않고 저널에도 적히지 않는다(시각축이 없는 값이다).\n   * 갈래 판정은 커널의 것을 부른다 — 다른 넷과 같은 규율이다.\n   *\n   * 설계: `operato-twin/design/plans/master-data.md`\n   */\n  const masterCandidates = arr.filter(isMasterDataRecord)\n  const master = masterCandidates.length ? ingestMasterData(masterCandidates) : { accepted: [], rejected: [] }\n  /*\n   * **어휘가 넷이다** — 물류(EPCIS)·에너지 계량·설비 에너지·운영 사실. 예전에는 이 함수가 무조건\n   * `ObjectEvent` 를 만들었고, 그래서 계측을 이 길로 넣으면 `epc` 가 없어 거부되거나(그나마 나은 쪽)\n   * 엉뚱한 물품 관측이 됐다.\n   *\n   * 물류 어휘 안에는 모양이 둘이다(개체 관측 `epc` / 담김 `parentID`+`childEPCs`).\n   *\n   * 판정은 커널이 한 곳에서 한다(`isEnergyRecord`·`isOperationalRecord`·`isAggregationRecord`) — 여기서 다시 짐작하면\n   * 소비처마다 답이 달라진다. 봉투는 같은 것을 쓰므로 아래 소비처(미러·저널·브로드캐스팅)는 이 갈림을 알\n   * 필요가 없다.\n   */\n  /*\n   * 여섯째·일곱째 어휘 — **마감된 사용 구간**과 **청구서**. 커널 0.7.72 가 이 문들을 열었다.\n   *\n   * ── ★ 사용 구간을 계량보다 **먼저** 가른다 ─────────────────────────────────\n   * `isEnergyRecord` 는 `meterId` 가 있으면 참이므로 사용 구간에도 참이다. 순서를 정하지 않으면\n   * 시간별 사용량이 계량 표본으로 들어가고, 그 문은 `kWh` 를 **적산 레지스터**로 읽는다. 그러면\n   * 커널이 구간 전력량을 차분으로 구하는데 우리가 넣은 값이 이미 구간의 양이다 — 차분의 차분이 되어\n   * 값이 조용히 틀린다. 거부되지도 않는다.\n   */\n  const usagePeriods = arr.filter(isEnergyUsagePeriodRecord) as unknown as EnergyUsagePeriodRecord[]\n  const bills = arr.filter(isEnergyBillRecord) as unknown as EnergyBillRecord[]\n  /*\n   * 여덟째 어휘 — **그 주기에 적용되는 요금 기준**. 커널 0.7.76 이 이 문을 열었다.\n   *\n   * ★ 청구서와 겹친다. 청구서가 `billingDemandKW` 를 실을 수 있고, 그러면 두 판정이 다 참이다.\n   * 그때 요금 기준 문으로 보내면 「금액은 이 문이 받지 않는다」로 거부된다 — 정산이 통째로\n   * 사라진다. 그래서 청구서인 것을 뺀다. 커널에서 배타로 만들어 달라고 올렸다.\n   */\n  const tariffBases = arr.filter(r => isEnergyTariffBasisRecord(r) && !isEnergyBillRecord(r)) as unknown as EnergyTariffBasisRecord[]\n  /*\n   * 아홉째 어휘 — **발전 단가**. 낸 것에 매겨지는 1kWh 당 값이고 날마다 바뀐다(커널 0.7.79).\n   *\n   * 다른 문과 겹치지 않는다: 계량 지점이나 설비 id 가 있으면 이 문이 아니고(커널이 배타로 막는다),\n   * 요금적용전력·기본요금 단가가 없으므로 요금 기준도 아니다.\n   */\n  const generationPrices = arr.filter(isEnergyGenerationPriceRecord) as unknown as EnergyGenerationPriceRecord[]\n  /* 마감된 발전 기간 — 지난 기록 채우기가 쓴다. 적산의 문과 배타다(구간이 있으면 이쪽). */\n  const generationPeriods = arr.filter(isEnergyGenerationPeriodRecord) as unknown as EnergyGenerationPeriodRecord[]\n  const energy = arr.filter(r => isEnergyRecord(r) && !isEnergyUsagePeriodRecord(r)) as EnergyRecord[]\n  /* 세 번째 어휘 — 설비가 낸 자기 에너지 상태(발전·저장·감축 여지·개폐 위치). 계량과 갈라 두는\n     이유는 커널에 적혀 있다: 계량은 구간에 누적되고, 이것들은 그 설비의 지금이다. */\n  /*\n   * 다섯 번째 어휘 — **발전 적산**(설비가 지금까지 만든 양). 커널 0.7.69 가 이 문을 열었다.\n   *\n   * ── ★ 설비 상태보다 **먼저** 가른다 ──────────────────────────────────────────\n   * 두 판정이 겹친다. `isEnergyEquipmentRecord` 는 `equipmentId` 가 있고 물류·계량 어휘가 아니면\n   * 참이므로 발전 적산도 함께 참이다. 그래서 순서가 갈림을 정한다.\n   *\n   * 순서를 잘못 두면 조용히 사라지는 것이 아니라 **엉뚱한 이유로 거부된다**: 설비 상태 문은 적산을\n   * 값으로 세지 않아 「바꿀 상태가 하나도 없다」로 돌려보낸다. 커넥터는 보냈다고 믿고, 화면에는\n   * 발전량이 없다.\n   */\n  const energyGeneration = arr.filter(isEnergyGenerationRecord) as unknown as EnergyGenerationRecord[]\n  const energyEquipment = arr.filter(r => isEnergyEquipmentRecord(r) && !isEnergyGenerationRecord(r)) as unknown as EnergyEquipmentRecord[]\n  /*\n   * 네 번째 어휘 — **운영 사실**(작업·설비·사람·자산·오더·품질). 관측 리듀서는 이것을 오래전부터\n   * 계산했는데 **들어올 문이 없었다**: 원본이 「이 작업이 끝났다」를 말할 길이 없어 시뮬 커널만 그것을\n   * 아는 상태가 남았다(같은 화면이 두 구동에서 다른 것을 말한다).\n   */\n  const operational = arr.filter(isOperationalRecord) as OperationalRecord[]\n  /*\n   * ── 이 목록은 **어휘를 더할 때마다 함께 늘어야 한다** (2026-08-30) ─────────\n   *\n   * EPCIS 갈래는 「나머지 전부」다. 새 어휘를 빼 주지 않으면 그 레코드가 제 문으로 가면서\n   * **EPCIS 문으로도 들어가** 거부된다. 받아들여지기도 하고 거부되기도 하는 상태가 되어,\n   * 유입 장부의 거부 수가 늘고 사람이 그것을 진짜 결함으로 읽는다.\n   *\n   * 실제로 발전 단가를 더할 때 그렇게 됐다. 목록을 손으로 지키는 대신 시험이 지킨다\n   * (§`canonical-ingest-vocabularies` — 어휘마다 한 문으로만 가는지).\n   */\n  const epcis = arr.filter(\n    r =>\n      !isEnergyRecord(r) &&\n      !isEnergyEquipmentRecord(r) &&\n      !isEnergyGenerationRecord(r) &&\n      !isEnergyUsagePeriodRecord(r) &&\n      !isEnergyBillRecord(r) &&\n      !isEnergyTariffBasisRecord(r) &&\n      !isEnergyGenerationPriceRecord(r) &&\n      !isEnergyGenerationPeriodRecord(r) &&\n      !isOperationalRecord(r) &&\n      !isMasterDataRecord(r)\n  ) as (CanonicalRecord | CanonicalAggregationRecord | CanonicalTransformationRecord)[]\n\n  /* 품목 어휘 안에서도 갈림이 있다(개체 관측 / 담김) — 그 판정도 커널의 것을 부른다. */\n  const epcisResult = epcis.length\n    ? ingest(\n        epcis.map(r => ({\n          ...r,\n          /*\n           * ── **시각의 이름을 둘 흡수한다** (2026-08-24 실측) ────────────────────\n           * `eventTimePath` 는 **한 이름**만 받는다. 호스트가 `'eventTime'` 으로 못박아 두었는데, 뒤에\n           * 생긴 커넥터는 `at` 을 싣는다(에너지 채널이 이미 `at` 을 쓰고 있어 그 어휘를 따랐다).\n           * 그래서 그 커넥터의 사건은 **전부 폴링 순간**으로 찍혔다 — 저널 18,150건이 그랬다.\n           *\n           * 그 결과 둘이 함께 망가졌다: 재고 관측이 트윈의 시계를 밀지 못해 시계가 `task.status` 의\n           * 최댓값(2026-04-15)에 **멈춰 있었고**, 이동 사건에서 「언제」가 사라져 순서만 남았다.\n           *\n           * 이름을 하나로 강요하지 않고 흡수한다 — `orderId`·`resourceRef`·`equipmentId` 를 함께 보는\n           * 것과 같은 규율이다(§`twin-event-keys`). 세대가 섞이는 것은 이 이음새의 성질이다.\n           *\n           * **없으면 만들지 않는다**: 절대값 스냅샷 관측은 원본의 갱신 시각이 아니라 **폴링 순간**이\n           * 맞는 관측 시각이다(「어제 값을 오늘 봤다」는 「어제 일어났다」가 아니다). 값을 말하는\n           * 레코드만 자기 시각을 갖는다.\n           */\n          /*\n           * ── 세 번째로 같은 자리를 밟았다 (2026-09-06) ────────────────────────\n           * 여기가 `eventTime ?? at` **두 이름만** 보고 있었다. `nonconformance.disposition` 은\n           * `data.decidedAt` 을 싣고(contract 가 required), 그래서 ingest 시각으로 떨어졌다 —\n           * backfill 로 5일 지난 사실을 받으니 5일 틀린 값이 저장됐다.\n           *\n           * 이름을 하나 더 넣는 것으로는 안 끝난다. type 마다의 칸을 한 표에 두고, 못 읽은 것은\n           * 세어서 낸다(§`event-time.ts`).\n           */\n          ...(factEventTime(r) !== undefined ? { eventTime: factEventTime(r) } : {}),\n          /* 판정은 커널이 한 곳에서 한다 — 여기서 다시 짐작하면 소비처마다 답이 달라진다. */\n          sourceType: isTransformationRecord(r)\n            ? 'twin-transformation'\n            : isAggregationRecord(r)\n              ? 'twin-aggregation'\n              : 'twin'\n        })).map((copy, i) => {\n          /* 사본 → 원본. 거절이 사본을 들고 나오면 이 지도로 되돌린다(§ 위 머리말). */\n          originalOf.set(copy, epcis[i])\n          return copy\n        }),\n        TWIN_INGEST_RULES,\n        /*\n         * **레코드가 시각을 말하면 그것을 쓴다** (2026-08-23).\n         *\n         * `eventTimePath` 를 주지 않던 동안 이 경로는 **언제나 폴링 시각**을 썼다(`defaultEventTime`).\n         * 그래서 커넥터가 이미 싣고 있던 `eventTime`(변환 레코드의 `finishedAt` 등)이 **알리지 않고\n         * 무시됐다** — 커넥터를 붙인 쪽은 그것이 먹는다고 믿고 있었고, 어디에도 오류가 나지 않았다.\n         *\n         * 무엇이 걸렸나: 계보(변환)의 시각이다. 4월에 만든 로트가 8월에 만들어진 것으로 저널에 남았다.\n         * 그리고 실측 소요를 재는 폴드가 봉투 시각을 쓰므로(§`kpi-fold`: `workMs = 완료 − 첫 착수`),\n         * 폴링 간격을 작업시간으로 배울 수 있었다 — 못 배우는 것보다 나쁘다.\n         *\n         * 레코드에 `eventTime` 이 없으면 커널이 알리지 않고 기본값으로 떨어진다(§`resolve` — 없는 값은\n         * 오류가 아니다). 그래서 이 한 줄이 기존 경로를 막지 않는다: 시각을 말하는 레코드만 사실이 된다.\n         */\n        { tenantId, defaultEventTime, eventTimePath: 'eventTime' }\n      )\n    : { accepted: [], rejected: [] }\n  const energyResult = energy.length ? ingestEnergyRecords(energy, { tenantId, defaultEventTime, ...scope }) : { accepted: [], rejected: [] }\n  const equipmentResult = energyEquipment.length\n    ? ingestEnergyEquipmentRecords(energyEquipment, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  const usageResult = usagePeriods.length\n    ? ingestEnergyUsagePeriodRecords(usagePeriods, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  const billResult = bills.length ? ingestEnergyBillRecords(bills, { tenantId, defaultEventTime, ...scope }) : { accepted: [], rejected: [] }\n  const tariffBasisResult = tariffBases.length\n    ? ingestEnergyTariffBasisRecords(tariffBases, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  const generationPeriodResult = generationPeriods.length\n    ? ingestEnergyGenerationPeriodRecords(generationPeriods, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  const generationPriceResult = generationPrices.length\n    ? ingestEnergyGenerationPriceRecords(generationPrices, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  const generationResult = energyGeneration.length\n    ? ingestEnergyGenerationRecords(energyGeneration, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n  /*\n   * ── fact type 마다 시각 칸 이름이 다르다 (2026-09-06) ────────────────────────\n   * 운영 레코드의 봉투 시각은 `at` 이다. 그런데 `nonconformance.disposition` 은 자기 시각을\n   * **payload 의 `decidedAt`** 에 싣는다(contract 가 그 자리에 required 로 선언했다). 그래서 `at` 이\n   * 없고 `defaultEventTime`(= ingest 시각)으로 떨어졌다.\n   *\n   * ```\n   * [측정함 2026-09-06, mes-line-a backfill 뒤]\n   * event_time  2026-09-05 23:50:51    data.decidedAt  2026-09-01T02:50:51.832Z    5일 차이\n   * ```\n   *\n   * push 경로에서는 몇 초 차이라 아무도 못 알아챈다. backfill 이 그 간격을 벌려서 드러냈다 —\n   * backfill 이 만든 결함이 아니라 원래 있던 것이 보인 것이다.\n   *\n   * 여기서 `at` 을 채워 넣는다. 더 깊은 고침은 contract 쪽이지만(선언과 봉투가 다른 이름을 쓰는\n   * 비대칭), 그것은 배포를 기다려야 하고 그동안 값이 계속 틀리게 저장된다.\n   */\n  const operationalDated = operational.map(r => {\n    const at = factEventTime(r)\n    return at !== undefined && (r as any).at === undefined ? { ...(r as any), at } : r\n  })\n  const operationalResult = operationalDated.length\n    ? ingestOperationalRecords(operationalDated, { tenantId, defaultEventTime, ...scope })\n    : { accepted: [], rejected: [] }\n\n  /* 거부분을 합쳐 돌려준다 — 어느 어휘에서 거부됐는지는 이유 문구가 말한다. */\n  return {\n    accepted: [\n      ...epcisResult.accepted,\n      ...energyResult.accepted,\n      ...equipmentResult.accepted,\n      ...generationResult.accepted,\n      ...usageResult.accepted,\n      ...generationPriceResult.accepted,\n      ...generationPeriodResult.accepted,\n      ...billResult.accepted,\n      ...tariffBasisResult.accepted,\n      ...operationalResult.accepted\n    ],\n    rejected: toOriginals(originalOf, [\n      ...epcisResult.rejected,\n      ...energyResult.rejected,\n      ...equipmentResult.rejected,\n      ...generationResult.rejected,\n      ...usageResult.rejected,\n      ...billResult.rejected,\n      ...tariffBasisResult.rejected,\n      ...generationPriceResult.rejected,\n      ...generationPeriodResult.rejected,\n      ...operationalResult.rejected,\n      ...master.rejected\n    ]),\n    /* 사건이 아닌 것은 따로 낸다 — 부르는 쪽이 상태 세우는 문으로 보낸다(저널로 가지 않게). */\n    masterData: master.accepted,\n    /*\n     * **시각을 못 읽어 ingest 시각으로 떨어진 것** — type 별 수.\n     *\n     * 오류가 아니다. 절대값 snapshot 은 polling 순간이 맞는 시각이라 여기 세어지는 것이 정상이다.\n     * 다만 그 수가 어디에도 안 남으면 `event_time == created_at` 이 유일한 단서가 되고, 그것은\n     * 우연히 같은 것과 구별되지 않는다.\n     */\n    undated: undatedByKind([...epcis, ...operational])\n  }\n}\n\n/**\n * 유입 결과 — 사건(봉투)과 **사건이 아닌 것**을 갈라 낸다.\n *\n * 마스터데이터를 `accepted` 에 섞지 않는 이유: 부르는 쪽이 그것을 저널에 적게 되고, 시각축이 없는 값이\n * 「그때 일어난 일」로 남는다. 갈래를 타입으로 갈라 두면 그 실수를 할 수 없다.\n */\nexport interface CanonicalIngestResult extends IngestResult {\n  masterData: MasterDataRecord[]\n  /**\n   * 시각을 못 읽어 ingest 시각으로 떨어진 record 를 **type 별로** 센다.\n   *\n   * 비어 있으면 전부 자기 시각을 말한 것이다. 값이 있어도 오류는 아니다 — 절대값 snapshot 은\n   * polling 순간이 맞는 시각이다. 다만 그 수가 남아야 「5일 틀린 값이 저장됐다」를 나중에 찾을 수\n   * 있다(2026-09-06 에 그것을 backfill 로 찾았다).\n   */\n  undated: Record<string, number>\n}\n"]}

package/dist-server/engine/checkpoint-fold.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkpoint-fold.js","sourceRoot":"","sources":["../../server/engine/checkpoint-fold.ts"],"names":[],"mappings":";;AAOA,8CAIC;AAXD;;;;;;GAMG;AACH,SAAgB,iBAAiB,CAAC,IAA0E;IAC1G,MAAM,CAAC,GAAG,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAA;IAC/D,IAAI,OAAO,CAAC,EAAE,kBAAkB,KAAK,UAAU;QAAE,OAAO,CAAC,CAAA;IACzD,OAAO,MAAM,CAAC,CAAC,CAAC,kBAAkB,EAAE,CAAC,IAAI,CAAC,CAAA;AAC5C,CAAC","sourcesContent":["/*\n * **체크포인트를 쓰기 직전에 끝난 오더를 접는다** — ADR-0092 결정 1.\n *\n * 커널은 스스로 접지 않는다. 접는 때를 체크포인트에 맞춰야 접힌 쪽이 씨앗과 같은 때에 적히고, 재기동 동치(`재개점 + 꼬리 ==\n * 0부터 접기`)가 선다. 그래서 체크포인트를 쓰는 호스트가 부른다. 두 구동이 가진 커널이 다르다 — 미러는 `projector`(관측 모드\n * 커널), 시뮬은 `kernel` 이다. 둘 중 그 구동의 것을 부르고, 접는 문이 없는 옛 커널이면 아무것도 하지 않는다.\n */\nexport function foldForCheckpoint(inst: { mode?: 'sim' | 'live'; projector?: any; kernel?: any } | undefined): number {\n  const k = inst?.mode === 'live' ? inst.projector : inst?.kernel\n  if (typeof k?.foldFinishedOrders !== 'function') return 0\n  return Number(k.foldFinishedOrders()) || 0\n}\n"]}

package/dist-server/engine/command-routing.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"command-routing.js","sourceRoot":"","sources":["../../server/engine/command-routing.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;;;AAgCH,oCAYC;AA1CD,6CAA6C;AAC7C,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAS,CAAC,eAAe,CAAC,CAAC,CAAA;AAoB9D,uCAAuC;AAChC,MAAM,WAAW,GAAG,CAAC,IAAY,EAAW,EAAE,CAAC,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AAAvE,QAAA,WAAW,eAA4D;AAEpF;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,IAAkC,EAAE,aAAsB,EAAE,IAAY;IACnG,IAAI,CAAC,IAAI,IAAI,CAAC,aAAa;QAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA;IAClF,IAAI,CAAC,IAAI;QAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,iBAAiB,EAAE,CAAA;IAEpE,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QACzB,+CAA+C;QAC/C,OAAO,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,CAAA;IAChG,CAAC;IAED,iDAAiD;IACjD,IAAI,IAAA,mBAAW,EAAC,IAAI,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,qBAAqB,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,EAAE,CAAA;IAC3G,OAAO,IAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,CAAA;AACtG,CAAC","sourcesContent":["/*\n * 커맨드 라우팅 판정 — **순수**. \"이 커맨드를 누구에게 보낼 것인가\" 만 정한다.\n * 실제 dispatch·저널 기록은 엔진이 한다(`design/plans/command-routing.md` §1·§4 P0).\n *\n * ── 왜 떼어냈나 ─────────────────────────────────────────────────────────────\n * 예전에는 리졸버가 `inst.runtime.dispatch(...)` 를 곧바로 불렀다. `runtime` 은 **시뮬 경로에서만**\n * 만들어지므로 실물을 비추는 트윈(mirror)에서는 그 한 줄이 `TypeError` 로 터졌다 — 조치 채널이\n * 통째로 닿지 않았고, 사용자에게는 이유 있는 거절이 아니라 그냥 실패였다.\n *\n * 판정이 코드 한가운데 있으면 이런 부류를 테스트로 못 잡는다(엔진은 DB·TypeORM 을 물고 있어 단위\n * 테스트가 불러올 수 없다). 그래서 판정만 순수하게 떼어 둔다 — `planWarmStart` 와 같은 이유다.\n *\n * ── 판정 규칙 = 권위 × 성격 ─────────────────────────────────────────────────\n * | 성격 \\ 모드      | 시뮬            | 미러(현실을 비춤)                    |\n * | 액추에이션        | 커널 런타임      | **거절**(아웃바운드 어댑터 미결선)     |\n * | 주석(확인 ack)    | 커널 런타임      | 관측 커널                            |\n *\n * 미러에서 액추에이션을 그냥 허용하면 **새 거짓말이 생긴다**: 트윈은 \"보류됨\" 이라 말하고 실 시스템은\n * 모른다. 알리지 않고 커널만 바꾸지 않고, 이유를 밝혀 거절한다.\n *\n * 반면 확인(ack)은 액추에이션이 아니다 — 신호를 봤다는 트윈 쪽 주석이라 현실을 건드리지 않는다.\n * 미러에서도 성립해야 하므로 관측 커널로 보낸다.\n */\n\n/** 관측 쪽 주석 커맨드 — 현실을 바꾸지 않으므로 미러에서도 통과한다. */\nconst ANNOTATION_COMMANDS = new Set<string>(['attention.ack'])\n\n/** 라우팅에 필요한 인스턴스 사실만 — 엔진 객체를 그대로 받지 않는다(순수하게 유지). */\nexport interface RoutableInstance {\n  /** 'live' 면 현실을 비추는 트윈(미러). 그 외는 시뮬. */\n  mode?: string\n  /** 커널 런타임(tick/dispatch)이 붙어 있나 — 시뮬 경로에서만 만들어진다. */\n  hasRuntime: boolean\n  /** 관측 커널이 dispatch 를 받을 수 있나. */\n  hasKernelDispatch: boolean\n}\n\nexport type CommandRoute =\n  /** 커널 런타임으로(시뮬 — 커널이 세계다). */\n  | { target: 'runtime' }\n  /** 관측 커널로(미러 — 주석만). 방출된 사실은 저널 큐에 실어야 한다. */\n  | { target: 'kernel' }\n  /** 보내지 않는다. 사유는 언어 중립 코드 — 화면이 `twin.cmderr.<code>` 로 사람 말을 만든다. */\n  | { target: 'reject'; errorCode: string; errorParams?: Record<string, string | number> }\n\n/** 이 커맨드가 실 프로세스를 바꾸는 것인가(= 액추에이션). */\nexport const isActuation = (type: string): boolean => !ANNOTATION_COMMANDS.has(type)\n\n/**\n * 어디로 보낼지 정한다.\n *\n * `inst` 가 없거나 호출자 도메인 소유가 아니면 **같은 사유로** 거절한다 — 존재 여부를 알려 주면\n * 다른 테넌트의 인스턴스 id 를 추측할 수 있다(있음/없음이 구별되면 그것이 정보다).\n */\nexport function routeCommand(inst: RoutableInstance | undefined, ownedByCaller: boolean, type: string): CommandRoute {\n  if (!inst || !ownedByCaller) return { target: 'reject', errorCode: 'no-instance' }\n  if (!type) return { target: 'reject', errorCode: 'unknown-command' }\n\n  if (inst.mode !== 'live') {\n    /* 시뮬 — 커널이 세계다. 런타임이 없으면 오류를 내지 않고 이유를 말한다. */\n    return inst.hasRuntime ? { target: 'runtime' } : { target: 'reject', errorCode: 'no-runtime' }\n  }\n\n  /* 미러 — 실 프로세스 변경은 아웃바운드 어댑터의 몫이고 아직 결선되지 않았다. */\n  if (isActuation(type)) return { target: 'reject', errorCode: 'actuation-not-wired', errorParams: { type } }\n  return inst.hasKernelDispatch ? { target: 'kernel' } : { target: 'reject', errorCode: 'no-runtime' }\n}\n"]}

package/dist-server/engine/declared-stimulus.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"declared-stimulus.js","sourceRoot":"","sources":["../../server/engine/declared-stimulus.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;AAsBH,oCAcC;AAOD,oCAEC;AA9BD;;;;;;GAMG;AACH,SAAgB,YAAY,CAC1B,MAAW,EACX,OAA8D,EAC9D,QAAuH;IAEvH,MAAM,QAAQ,GAAG,MAAM,EAAE,QAAQ,CAAA;IACjC,IAAI,CAAC,QAAQ,IAAI,OAAO,QAAQ,KAAK,QAAQ;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAA;IACxF,+DAA+D;IAC/D,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,CAAA;IAC1E,IAAI,CAAC,OAAO,CAAC,iBAAiB;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,CAAA;IAC9E,IAAI,CAAC,QAAQ;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAA;IAC7F,MAAM,CAAC,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC5B,IAAI,CAAC,CAAC,EAAE,EAAE;QAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAG,CAAS,EAAE,SAAS,IAAI,UAAU,EAAE,CAAA;IACrG,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;AACrC,CAAC;AAED;;;;GAIG;AACH,SAAgB,YAAY,CAAC,MAAW,EAAE,QAAa;IACrD,OAAO,EAAE,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAA;AACxC,CAAC","sourcesContent":["/*\n * **자극은 원본이 선언한다** — 트윈이 아니라.\n *\n * ── 무엇이 났나 (2026-08-19) ────────────────────────────────────────────────\n * 데모의 자극(시나리오)은 시드 코드가 **메모리에만** 실었다: `runtime.scenario.load(...)`. 그래서 트윈을\n * 재기동하면 자극이 사라지고, 구조만 서 있는 트윈이 남는다 — 작업 0·오더 0. 「살아 있는 데모」가\n * **첫 재기동까지만** 사는 것이다(오늘 서버를 여러 번 띄우는 동안 실제로 그 상태였다).\n *\n * ── 왜 트윈에 저장하지 않나 (ADR-0029 · plans/simulator-as-source.md §4) ────\n * 자극은 **원본의 거동**이다: 무엇이 들어오고 무슨 주문이 나는지는 시뮬레이터(원본)가 정하는 사실이고,\n * 트윈은 그것을 반영한다. 트윈에 새 축을 만들면 ADR-0029 가 나중에 걷어내야 하는 표면이 하나 늘고\n * (그 계획서의 §2·§5 가 이미 그 부담을 적어 두었다), 원본에 두면 그 계획의 **첫 조각 앞자리**가 된다:\n * 지금은 호스트가 읽어 커널에 싣고, 나중에 `openLiveFeed` 뒤로 옮기면 같은 선언이 그대로 쓰인다.\n *\n * 그래서 집은 `TwinReference.connectionConfig.scenario` — 어댑터별 설정 자리(이미 `simple-json`)다.\n *\n * ── 판정을 순수 함수로 (이 파일) ────────────────────────────────────────────\n * 「이 트윈에 저장된 자극을 실을 것인가」에는 사람이 틀리기 쉬운 갈림이 셋 있다: 미러에 실으면 **현실을\n * 오염**시키고, 잘못된 선언을 실으면 **다음 틱에서 서버가 내려가고**(실제로 그 이력이 있다), 시나리오\n * 엔진이 없는 런타임에 실으면 알리지 않고 아무 일도 없다. 그래서 판정을 값으로 만들고 시험한다.\n */\n\n/** 자극을 실을지 말지 — 그리고 왜. 부르는 쪽은 이 답만 보고 움직인다. */\nexport type StimulusPlan =\n  /** 실어라 — 검사를 통과한 선언. */\n  | { action: 'load'; scenario: any }\n  /**\n   * 싣지 않는다 — 그 이유.\n   *  · `none`        — 원본이 자극을 선언하지 않았다(정상: 정적 구조만 반영하는 트윈)\n   *  · `mirror`      — 미러다. 외부 실물이 진실인 트윈에 우리가 자극을 만들면 그것은 현실이 아니다\n   *  · `no-engine`   — 이 런타임에 시나리오 엔진이 없다(관측 구동 커널)\n   *  · `invalid`     — 선언이 커널 규약을 어긴다. **싣지 않고 말한다**(다음 틱에서 터지게 두지 않는다)\n   */\n  | { action: 'skip'; reason: 'none' | 'observed' | 'no-engine' | 'invalid'; detail?: string }\n\n/**\n * 저장된 자극 선언을 읽어 **실을지 판정한다** — 커널 검사기를 그대로 쓴다(규칙을 두 벌로 만들지 않는다).\n *\n * `validate` 는 커널의 `validateScenario` 를 넘긴다(호스트가 커널 타입에 묶이지 않게 함수로 받는다).\n * 검사기가 없으면 **싣지 않는다**: 검사할 수 없는 선언을 태우는 것이 가장 비싼 선택이다(서버가 내려간\n * 이력이 있다).\n */\nexport function planStimulus(\n  config: any,\n  runtime: { hasScenarioEngine: boolean; mode?: 'sim' | 'live' },\n  validate?: (scenario: any) => { ok: boolean; errorCode?: string; errorParams?: any } | { ok: false; errorCode: string }\n): StimulusPlan {\n  const scenario = config?.scenario\n  if (!scenario || typeof scenario !== 'object') return { action: 'skip', reason: 'none' }\n  /* 관측 트윈을 먼저 막는다 — 「엔진이 없다」로 답하면 이유가 흐려진다(애초에 실을 수 없는 트윈이다). */\n  if (runtime.mode === 'live') return { action: 'skip', reason: 'observed' }\n  if (!runtime.hasScenarioEngine) return { action: 'skip', reason: 'no-engine' }\n  if (!validate) return { action: 'skip', reason: 'invalid', detail: 'no validator available' }\n  const v = validate(scenario)\n  if (!v?.ok) return { action: 'skip', reason: 'invalid', detail: (v as any)?.errorCode ?? 'rejected' }\n  return { action: 'load', scenario }\n}\n\n/**\n * 선언을 원본 설정에 얹는다(순수) — **기존 설정을 지우지 않는다.**\n *\n * 어댑터 설정에는 접속 정보가 함께 산다. 자극을 넣으면서 그 옆을 덮으면 다음 재동기가 원본을 못 찾는다.\n */\nexport function withStimulus(config: any, scenario: any): any {\n  return { ...(config ?? {}), scenario }\n}\n"]}

package/dist-server/engine/energy-topology.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"energy-topology.js","sourceRoot":"","sources":["../../server/engine/energy-topology.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 전력 계통도 — **선언된 것만 그린다.** 순수.\n *\n * ── 왜 필요한가 (2026-08-18) ────────────────────────────────────────────────\n * 분기별 막대는 「어디가 많이 쓰나」에 답하지만 **어디에 걸려 있나**에 답하지 못한다. 실제로 부딪힌\n * 세 가지가 전부 계통 질문이었다:\n *  · 「하위 계량이 덮지 않는 327 kWh」 — 그 몫이 수전 직결 부하인지, 계량 없는 구간인지 표로는 모른다.\n *  · 커넥터는 결선을 모르는 부하를 **수전에 매단다**(정직한 선택). 그런데 그 사실이 화면에 없었다.\n *  · 「계량기를 어디에 더 달아야 하나」 — 어두운 구간이 보여야 답할 수 있다.\n *\n * ── 무엇을 그리지 않나 ─────────────────────────────────────────────────────\n * **보호 계통 단선도(SLD)가 아니다.** 차단기 정격·보호 협조·상(phase)·결선 방식은 모델에 없고, 그럴듯한\n * 단선도를 그리면 갖지 않은 공학적 충실도를 주장하게 된다. 여기서 그리는 것은 **트윈이 선언한 관계**\n * (자리의 계층 + 설비의 소속)와 **계량이 실제로 덮는 범위**뿐이다. 한계는 소비처가 화면에 적는다.\n *\n * ── 알리지 않고 빠뜨리지 않는다 ─────────────────────────────────────────────────\n * 자리를 모르는 설비, 계량기가 없는 자리, 계량이 덮지 않는 몫은 **각자 자기 칸으로** 나온다. 그림에서\n * 사라지면 사용자는 자기 현장이 다 그려졌다고 믿는다.\n */\nimport { EMS_LOCATION_TYPES, electricalUpstreamOf } from '@operato/ops-contract'\n\n/** 계통의 한 구간(수전·분기·구역) — 자리 하나가 곧 구간이다. */\nexport interface TopologySegment {\n  id: string\n  /** 카탈로그 자리 타입(`incoming`·`feeder`·`submeter-zone`). */\n  type: string\n  label?: string\n  /** 이 자리에 달린 계량 지점 id 들 — 비어 있으면 **어두운 구간**이다(값을 알 길이 없다). */\n  meters: string[]\n  /** 이 구간의 전력량과 근거 — 폴드가 낸 것만 싣는다(우리가 다시 계산하지 않는다). */\n  kWh?: number\n  basis?: 'measured' | 'apportioned'\n  /**\n   * **피크가 찍힌 순간** 이 구간이 얼마였나(kW) — 요금이 걸린 수다.\n   *\n   * 전력량이 큰 구간과 피크를 만든 구간은 다를 수 있다(하루 종일 조금씩 쓰는 부하 vs 잠깐 크게 쓰는 부하).\n   * 그림에 둘을 함께 두면 「어느 분기를 깎아야 피크가 내려가나」가 바로 읽힌다.\n   */\n  peakKW?: number\n  /** 이 자리에 매달린 부하(설비) — 종류를 그대로 싣는다. */\n  loads: { id: string; kind: string }[]\n  /**\n   * 계통 설비(차단기·태양광·축전지) — 부하가 아니라 계통의 일부다.\n   *\n   * `live` 는 **지금 값**이다(구간 값이 아니다): 태양광이 지금 몇 kW 를 만들고, 축전지가 얼마를 내보내며\n   * 충전율이 얼마인가. 원천이 보내 주는 사실이라 우리가 만들지 않는다 — 보내지 않은 필드는 없다.\n   *\n   * 시각(`measuredAt`)을 함께 나른다: 계측이 끊기면 **멈춘 값을 지금 값으로 그리게** 되고, 그것이 화면이\n   * 낼 수 있는 가장 나쁜 거짓이다(값이 그럴듯할수록 위험하다).\n   */\n  gear: {\n    id: string\n    kind: string\n    live?: { generatedKW?: number; exportKW?: number; chargeKW?: number; dischargeKW?: number; soc?: number; measuredAt?: string }\n  }[]\n  children: TopologySegment[]\n}\n\nexport interface EnergyTopology {\n  roots: TopologySegment[]\n  /**\n   * 자리를 모르는 설비 — 집이 없거나, 없는 자리를 가리킨다. 숨기면 그림의 설비 수가 모델과 달라진다.\n   */\n  unplaced: { id: string; kind: string }[]\n  /** 계량기가 없는 자리 id 들 — 「여기에 달면 무엇을 알 수 있나」의 답이 되는 목록이다. */\n  unmetered: string[]\n  /**\n   * 결선을 모르는 부하가 매달린 자리 — 커넥터가 「어느 분기가 이 설비에 전기를 주는지 모른다」고 판단해\n   * 수전에 매단 경우다. 그 자리의 몫이 분기로 내려가지 않는 이유가 이것이다.\n   */\n  loadsOnIncoming: number\n}\n\n/**\n * 이 설비의 **지금 값** — 스냅샷에서 그 설비를 찾아 에너지 축의 값만 옮긴다.\n *\n * 종류가 아는 필드만 옮긴다: 태양광에 충전율을 붙이거나 축전지에 발전량을 붙이면, 화면은 그것을 사실로\n * 그리고 사람은 그 설비가 그런 일을 한다고 읽는다(커널이 종류별로 필드를 가려 받는 것과 같은 규율).\n */\nfunction liveOf(\n  state: readonly any[] | undefined | null,\n  id: string,\n  kind: string\n): { live: NonNullable<TopologySegment['gear'][number]['live']> } | undefined {\n  const e = (state ?? []).find(x => String(x?.id ?? '') === id)\n  if (!e) return undefined\n  const num = (v: unknown): number | undefined => (Number.isFinite(Number(v)) ? Number(v) : undefined)\n  const live: NonNullable<TopologySegment['gear'][number]['live']> = {}\n  if (kind === 'pv-array') {\n    const g = num(e.generatedKW)\n    const x = num(e.exportKW)\n    if (g !== undefined) live.generatedKW = g\n    if (x !== undefined) live.exportKW = x\n  } else if (kind === 'battery') {\n    const soc = num(e.soc)\n    const dis = num(e.dischargeKW)\n    const cha = num(e.chargeKW)\n    if (soc !== undefined) live.soc = soc\n    if (dis !== undefined) live.dischargeKW = dis\n    if (cha !== undefined) live.chargeKW = cha\n  }\n  if (!Object.keys(live).length) return undefined\n  /* 값이 있으면 시각도 함께 — 없으면 붙이지 않는다(모르는 시각을 지금으로 만들지 않는다). */\n  if (e.measuredAt) live.measuredAt = String(e.measuredAt)\n  return { live }\n}\n\nconst ELECTRICAL = new Set(EMS_LOCATION_TYPES as readonly string[])\n/** 부하가 아닌 계통 설비 — 이것들의 소비를 부하로 세면 총량이 이중으로 나뉜다. */\nconst GEAR = new Set(['meter', 'breaker', 'pv-array', 'battery'])\n\n/**\n * 모델 + 폴드 결과 → 계통 트리.\n *\n * @param model     트윈 모델(자리 계층 `parentId`, 설비 소속 `homeLocation`).\n * @param energy    폴드가 낸 분기별 몫(있으면 노드에 싣는다 — 없으면 값 없이 구조만 그린다).\n */\nexport function buildEnergyTopology(\n  model: { locations?: any[]; equipment?: any[] } | undefined | null,\n  energy?: { byFeeder?: { key: string; kWh: number; basis?: 'measured' | 'apportioned'; peakKW?: number }[] } | null,\n  /**\n   * 지금의 설비 상태(스냅샷의 `equipment`) — 발전·저장의 **지금 값**을 기호 옆에 적기 위해서다.\n   *\n   * 없으면 값 없이 구조만 그린다. 여기서 값을 만들지 않는다: 원천이 보내지 않은 것은 모르는 것이다.\n   */\n  equipmentState?: readonly any[] | null\n): EnergyTopology {\n  const locations: any[] = (model?.locations ?? []).filter(n => n?.id && ELECTRICAL.has(String(n.type)))\n  const byId = new Map<string, TopologySegment>()\n  for (const n of locations) {\n    byId.set(String(n.id), {\n      id: String(n.id),\n      type: String(n.type),\n      ...(n.name ? { label: String(n.name) } : {}),\n      meters: [],\n      loads: [],\n      gear: [],\n      children: []\n    })\n  }\n\n  const share = new Map((energy?.byFeeder ?? []).map(f => [f.key, f]))\n  for (const [id, segment] of byId) {\n    const s = share.get(id)\n    if (s) {\n      segment.kWh = s.kWh\n      if (s.basis) segment.basis = s.basis\n      if (typeof s.peakKW === 'number') segment.peakKW = s.peakKW\n    }\n  }\n\n  /* 설비를 자기 자리에 붙인다 — 계량기는 「이 구간을 잰다」는 뜻이라 따로 모은다. */\n  const unplaced: { id: string; kind: string }[] = []\n  let loadsOnIncoming = 0\n  for (const e of (model?.equipment ?? []) as any[]) {\n    if (!e?.id) continue\n    const kind = String(e.kind ?? '')\n    const home = String(e.homeLocation ?? e.homeLocationId ?? '')\n    const at = byId.get(home)\n    if (!at) {\n      /* 전기 계통 밖의 자리에 사는 설비도 여기서는 「자리를 모른다」로 모은다 — 이 그림의 축은 계통이다. */\n      unplaced.push({ id: String(e.id), kind })\n      continue\n    }\n    if (kind === 'meter') at.meters.push(String(e.id))\n    else if (GEAR.has(kind)) at.gear.push({ id: String(e.id), kind, ...(liveOf(equipmentState, String(e.id), kind) ?? {}) })\n    else {\n      at.loads.push({ id: String(e.id), kind })\n      if (at.type === 'incoming') loadsOnIncoming++\n    }\n  }\n\n  /*\n   * 계층을 잇는 것은 **전기 상류**다 — 공간 부모(공장·구역)는 이 축이 아니다. 상류의 뜻은 커널이 읽는다\n   * (옛 세대는 그 안에서 흡수된다) — 여기서 다시 판정하면 화면과 계산이 다른 계통을 말하게 된다.\n   */\n  const roots: TopologySegment[] = []\n  const all = model?.locations ?? []\n  for (const n of locations) {\n    const segment = byId.get(String(n.id))!\n    const up = electricalUpstreamOf(all as any, String(n.id))\n    const parent = up ? byId.get(up) : undefined\n    if (parent && parent !== segment) parent.children.push(segment)\n    else roots.push(segment)\n  }\n\n  const unmetered = [...byId.values()].filter(n => !n.meters.length).map(n => n.id)\n  return { roots, unplaced, unmetered, loadsOnIncoming }\n}\n"]}

package/dist-server/engine/event-time.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"event-time.js","sourceRoot":"","sources":["../../server/engine/event-time.ts"],"names":[],"mappings":";;;AA+DA,sCAQC;AAWD,sCAQC;AAGD,wCAEC;AA/FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wDAAyD;AAEzD;;;;GAIG;AACU,QAAA,eAAe,GAA2B;IACrD,+DAA+D;IAC/D,WAAW,EAAE,WAAW;CACzB,CAAA;AAED;;;;GAIG;AAEH,SAAS,GAAG,CAAC,CAAU;IACrB,OAAO,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC1D,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,MAAe;IAC3C,MAAM,CAAC,GAAG,MAAa,CAAA;IACvB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;IAC9C,IAAI,MAAM;QAAE,OAAO,MAAM,CAAA;IAEzB,MAAM,IAAI,GAAG,IAAA,gCAAiB,EAAC,MAAM,CAAC,CAAA;IACtC,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,uBAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IACtD,OAAO,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;AAC5C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,aAAa,CAAC,OAA2B;IACvD,MAAM,GAAG,GAA2B,EAAE,CAAA;IACtC,KAAK,MAAM,CAAC,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,aAAa,CAAC,CAAC,CAAC,KAAK,SAAS;YAAE,SAAQ;QAC5C,MAAM,IAAI,GAAG,IAAA,gCAAiB,EAAC,CAAC,CAAC,IAAM,CAAS,EAAE,IAAe,IAAI,SAAS,CAAA;QAC9E,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;IAClC,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,2CAA2C;AAC3C,SAAgB,cAAc,CAAC,IAAY;IACzC,OAAO,IAAI,IAAI,uBAAe,CAAA;AAChC,CAAC","sourcesContent":["/*\n * **레코드가 말하는 「언제 일어났나」를 읽는다** — fact 종류마다 칸 이름이 다르다.\n *\n * ── 같은 defect 가 세 번째다 ────────────────────────────────────────────────\n * `canonical-ingest.ts` 가 `eventTime ?? at` **두 이름만** 보고 있었다. 그 주석에 이미 두 번의 사고가\n * 적혀 있다 — 처음엔 `eventTime` 하나만 봐서 energy connector 의 사실 18,150건이 polling 시각으로\n * 찍혔고, 그 다음에 `at` 을 더했다.\n *\n * 세 번째는 `nonconformance.disposition` 이었다.\n *\n * ```\n * [측정함 2026-09-06, mes-line-a backfill 뒤]\n * event_time  2026-09-05 23:50:51    payload decidedAt  2026-09-01T02:50:51.832Z     5일 차이\n * ```\n *\n * ── root cause: 선언과 봉투가 다른 이름을 쓴다 ──────────────────────────────\n * 운영 레코드의 봉투 시각은 `at` 이다(`OperationalRecordEnvelopeFields`). 그런데 처분 fact 는 자기\n * 시각을 **payload 의 `decidedAt`** 에 싣는다 — contract 가 그 자리에 required 로 선언했고 plant 도\n * 맞게 보낸다. 읽는 쪽에 그 이름이 없어서 `defaultEventTime`(= ingest 시각)으로 떨어졌다.\n *\n * ── push 경로에서는 안 보인다 ───────────────────────────────────────────────\n * 사실이 나자마자 보내면 ingest 시각과 event 시각이 몇 초 차이다. backfill 이 그 간격을 벌려서\n * 드러냈다 — **backfill 이 만든 defect 가 아니라 원래 있던 것이 보인 것**이다.\n *\n * ── 이름을 늘리는 것으로는 안 끝난다 ────────────────────────────────────────\n * 다음 fact 종류가 또 다른 이름을 쓰면 같은 자리를 밟는다. 그래서 두 가지를 함께 한다.\n *\n * ```\n * 1  종류마다의 칸 이름을 한 표에 둔다     새 종류를 더할 때 여기가 눈에 띈다\n * 2  못 읽으면 그 수를 낸다                조용히 ingest 시각으로 떨어지지 않는다\n * ```\n *\n * 종류 판정은 **contract 의 것을 부른다**(`operationalKindOf`). 여기서 다시 짐작하면 두 곳이 다른\n * 답을 내고, 그때 어느 쪽이 맞는지 아무도 모른다.\n */\nimport { operationalKindOf } from '@operato/ops-contract'\n\n/**\n * 운영 fact 종류가 자기 시각을 싣는 칸 — 봉투의 `at` 이 없을 때 읽는다.\n *\n * 새 종류가 자기 시각을 payload 에 실으면 여기 한 줄을 더한다.\n */\nexport const KIND_TIME_FIELD: Record<string, string> = {\n  /* `DispositionFact.decidedAt` — contract 가 required 로 선언했다. */\n  disposition: 'decidedAt'\n}\n\n/*\n * `equipment-period` 는 일부러 안 넣는다. 그 fact 의 봉투 시각은 **구간의 끝**이고(그때 성립한다),\n * `recordTime` 은 「그 구간을 언제 적었나」다. 둘이 갈려 있어야 늦게 적은 구간이 늦게 일어난 것으로\n * 읽히지 않는다 — contract 가 그 판단을 이미 적어 두었다.\n */\n\nfunction iso(v: unknown): string | undefined {\n  return typeof v === 'string' && v.trim() ? v : undefined\n}\n\n/**\n * 이 레코드가 말하는 시각. **못 읽으면 `undefined`** — 여기서 지금 시각으로 채우지 않는다.\n *\n * 보는 순서는 공통 이름이 먼저다. connector 가 봉투 층에서 시각을 실어 주면 그것이 그 레코드에 대한\n * 가장 바깥의 판단이고, 종류마다의 칸은 그것이 없을 때 읽는다.\n */\nexport function factEventTime(record: unknown): string | undefined {\n  const r = record as any\n  const common = iso(r?.eventTime) ?? iso(r?.at)\n  if (common) return common\n\n  const kind = operationalKindOf(record)\n  const named = kind ? KIND_TIME_FIELD[kind] : undefined\n  return named ? iso(r?.[named]) : undefined\n}\n\n/**\n * 시각을 못 읽은 레코드를 종류별로 센다 — **조용히 ingest 시각으로 떨어진 것들.**\n *\n * 오류가 아니다. 절대값 snapshot 관측은 원본의 갱신 시각이 아니라 polling 순간이 맞는 시각이라\n * (「어제 값을 오늘 봤다」는 「어제 일어났다」가 아니다) 여기 세어지는 것이 정상이다.\n *\n * 다만 그 수가 어디에도 안 남으면 `event_time == created_at` 이 유일한 단서가 되고, 그것은 우연히\n * 같은 것과 구별되지 않는다.\n */\nexport function undatedByKind(records: readonly unknown[]): Record<string, number> {\n  const out: Record<string, number> = {}\n  for (const r of records) {\n    if (factEventTime(r) !== undefined) continue\n    const kind = operationalKindOf(r) ?? ((r as any)?.type as string) ?? '(종류 모름)'\n    out[kind] = (out[kind] ?? 0) + 1\n  }\n  return out\n}\n\n/** 표에 있는 종류인데 시각을 못 읽었다 — 그것은 실제로 결함이다. */\nexport function shouldHaveTime(kind: string): boolean {\n  return kind in KIND_TIME_FIELD\n}\n"]}

package/dist-server/engine/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../server/engine/index.ts"],"names":[],"mappings":";;;;AAAA,2DAAgC;AAChC,gEAAqC;AACrC,wDAA6B;AAC7B,gEAAqC;AACrC,4DAAiC;AACjC,qEAAqE;AACrE,0DAA+B;AAC/B,qGAA0E;AAC1E,0DAA0D;AAC1D,oGAAyE;AACzE,4CAA4C;AAC5C,kGAAuE;AACvE,sCAAsC;AACtC,0DAA+B;AAC/B,wDAA6B;AAC7B,gEAAgE;AAChE,2DAAgC;AAChC,yDAA8B;AAC9B,6DAAkC;AAClC,gEAAqC;AACrC,kEAAuC;AACvC,2DAAgC;AAChC,kEAAuC;AACvC,gDAAgD;AAChD,6DAAkC;AAClC,yDAAyD;AACzD,kEAAuC;AACvC,+DAAoC;AACpC,8DAAmC;AACnC,iEAAsC;AACtC,oEAAyC;AAEzC;;;;;;;;;GASG;AACH,uDAAiD;AAAxC,gHAAA,YAAY,OAAA;AAErB;;;;;GAKG;AACH,iDAA8E;AAArE,8GAAA,aAAa,OAAA;AAAE,+GAAA,cAAc,OAAA;AAAE,8GAAA,aAAa,OAAA","sourcesContent":["export * from './twin-engine.js'\nexport * from './canonical-ingest.js'\nexport * from './kpi-fold.js'\nexport * from './property-effects.js'\nexport * from './kpi-baseline.js'\n/* 지표 정본 표(TWIN_METRIC)·목표 판정 — 소비처(twin-ai 등)가 지표 이름을 다시 열거하지 않게. */\nexport * from './kpi-target.js'\nexport * from '@things-factory/headless-twin/dist-shared/kpi-broadcast.js'\n/* 집약 채널 태그(접두사 + 트윈별 태그 생성) — 소비처가 문자열을 다시 적지 않게 내보낸다. */\nexport * from '@things-factory/headless-twin/dist-shared/entity-delta.js'\n/* 공간 계층의 단계 — 씬 표현·성과 카드·AI 가 같은 목록을 쓴다. */\nexport * from '@things-factory/headless-twin/dist-shared/twin-level.js'\n/* 부하 계기판 — 어떤 작업이 이벤트 루프를 얼마나 쓰는지. */\nexport * from './load-meter.js'\nexport * from './loop-lag.js'\n/* 런타임 레지스트리 키 규약 — 소비처(다른 키 캐시·테스트)가 `:` 를 다시 적지 않게 함께 내보낸다. */\nexport * from './runtime-key.js'\nexport * from './kpi-query.js'\nexport * from './spec-coverage.js'\nexport * from './travel-estimator.js'\nexport * from './measured-estimator.js'\nexport * from './model-basis.js'\nexport * from './live-feed-registry.js'\n/* 동기화 건강 — 「이 트윈이 현장과 맞춰지고 있나」. 판정·추이·사유·표본. */\nexport * from './ingest-health.js'\n/* 로컬 선언(현장·트윈) — 소비처(twin-ai 도구)가 명세·검사 규칙을 다시 적지 않게. */\nexport * from './local-declarations.js'\nexport * from './operation-basis.js'\nexport * from './measured-yield.js'\nexport * from './declared-stimulus.js'\nexport * from './integration-coverage.js'\n\n/*\n * 사실의 정체(identity)와 시각을 판단하는 함수들.\n *\n * 모듈 전체를 export 하지 않고 이 둘만 내보낸다. `FactDeduper` 같은 상태를 가진 클래스는 커널\n * 안에서만 쓰여야 하고, 밖에서 인스턴스를 따로 만들면 중복 판단 기억이 두 벌이 된다.\n *\n * 밖에서 이 둘이 필요한 이유는 하나다 — 저널에 앉은 사실이 제대로 된 정체와 시각을 가졌는지\n * 확인할 때, 유입할 때와 **똑같은 함수로** 판단해야 하기 때문이다. 확인하는 쪽이 규칙을 다시\n * 구현하면 두 규칙이 어긋나는 날 확인이 조용히 통과한다.\n */\nexport { factIdentity } from './ingest-dedupe.js'\n\n/*\n * `shouldHaveTime` is the part that matters outside: it separates \"this record legitimately has no\n * time of its own\" (a snapshot observation — the polling moment IS the right time) from \"the kind\n * declares a time field and we could not read it\", which is a real defect. Anything checking the\n * journal must use this split rather than inventing its own, or it reports healthy rows as broken.\n */\nexport { factEventTime, shouldHaveTime, undatedByKind } from './event-time.js'\n"]}

package/dist-server/engine/ingest-dedupe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest-dedupe.js","sourceRoot":"","sources":["../../server/engine/ingest-dedupe.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8FAAmE","sourcesContent":["/*\n * Moved to `@things-factory/ingest`.\n *\n * ── Why this file is now two lines (2026-09-09) ───────────────────────────\n * When the `ingest` module was created, this judgement was reported as moved there. It was\n * copied: identical text in both places, twenty callers here and none there. A module published\n * with a copy nobody uses is the \"same machine twice\" this platform keeps warning other lanes\n * about, and it was mine.\n *\n * `ingest` is the home, because the module exists so that wms, yms and ems can use the same\n * judgement — that was the instruction it was built on. The file has no imports, so it lives in\n * that package's `shared/` and the flow badge on the screen reads the same one.\n *\n * ── Why the dependency in this direction is acceptable ───────────────────\n * A kernel host depending on a product module is normally the direction the approval gateway\n * exists to avoid, because that module drags an org chart and screens with it. Measured here it\n * does not: `ingest` depends on `shell` and `auth-base`, and this package already depends on\n * both. The deep specifier also means the barrel — and with it the entity and the client — is\n * never loaded.\n *\n * This re-export stays so the twenty call sites keep their import path. Its only job is to say\n * where the concept lives.\n */\nexport * from '@things-factory/ingest/dist-shared/ingest-dedupe.js'\n"]}

package/dist-server/engine/ingest-health.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ingest-health.js","sourceRoot":"","sources":["../../server/engine/ingest-health.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8FAAmE","sourcesContent":["/*\n * Moved to `@things-factory/ingest`.\n *\n * ── Why this file is now two lines (2026-09-09) ───────────────────────────\n * When the `ingest` module was created, this judgement was reported as moved there. It was\n * copied: identical text in both places, twenty callers here and none there. A module published\n * with a copy nobody uses is the \"same machine twice\" this platform keeps warning other lanes\n * about, and it was mine.\n *\n * `ingest` is the home, because the module exists so that wms, yms and ems can use the same\n * judgement — that was the instruction it was built on. The file has no imports, so it lives in\n * that package's `shared/` and the flow badge on the screen reads the same one.\n *\n * ── Why the dependency in this direction is acceptable ───────────────────\n * A kernel host depending on a product module is normally the direction the approval gateway\n * exists to avoid, because that module drags an org chart and screens with it. Measured here it\n * does not: `ingest` depends on `shell` and `auth-base`, and this package already depends on\n * both. The deep specifier also means the barrel — and with it the entity and the client — is\n * never loaded.\n *\n * This re-export stays so the twenty call sites keep their import path. Its only job is to say\n * where the concept lives.\n */\nexport * from '@things-factory/ingest/dist-shared/ingest-health.js'\n"]}

package/dist-server/engine/integration-coverage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-coverage.js","sourceRoot":"","sources":["../../server/engine/integration-coverage.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * **원본의 표면 중 얼마를 분류했나** — 순수(import 없음).\n *\n * ── 왜 이 축이 생겼나 (2026-08-20) ──────────────────────────────────────────\n * 탐침 열한 개는 「이 단계가 되나」를 묻는다. `live-ingest` 는 **레코드 한 건이 통과하면 초록**이다.\n * 그래서 재고만 읽는 커넥터에도 「라이브 통과」가 나왔고, 그 사이 원본의 `production_input`(무엇으로\n * 무엇을 만들었나 · 실제 투입량 · 선언된 필요량)과 오더 네 종류와 팔레트가 읽히지 않고 있었다.\n *\n * 그것들은 대화에서 하나씩 「아차」로 드러났다. 그 방식은 반복된다 — 빠진 것을 기억으로 찾기 때문이다.\n * 그래서 축을 하나 더 둔다: **원본이 내놓는 표면을 세고, 그 각각을 커넥터가 무엇으로 처리하는지 적는다.**\n *\n * ── 규율 ────────────────────────────────────────────────────────────────────\n * 표면 목록은 **원본에서 얻는다**(GraphQL 인트로스펙션 등). 커넥터가 손으로 적은 목록으로 세면 같은\n * 눈먼 자리를 그대로 물려받는다 — 내가 잊은 표는 목록에도 없다.\n *\n * 「읽지 않는다」는 결론은 **정당할 수 있다.** 파생 표(집계·추적)나 우리 어휘에 자리가 없는 것을 읽지\n * 않는 것은 결함이 아니다. 결함은 **분류하지 않은 것**이다 — 그것은 생각한 적이 없다는 뜻이다.\n *\n * 그래서 판정은 「전부 읽었나」가 아니라 **「전부 판단했나」** 다.\n */\n\n/**\n * 표면 하나를 커넥터가 무엇으로 처리하는가 — **각 낱말에 적용 가능한 기준과 조치할 사람이 있다.**\n * 기준이 없으면 분류가 느낌이 되고, 조치자가 없으면 표를 읽어도 누가 움직일지 알 수 없다.\n *\n *  · `read`      — **지금 커넥터가 질의한다.** 기준: 커넥터 코드에 그 질의 이름이 있다(확인 가능).\n *                  조치자: 없음(완료분).\n *\n *  · `todo`      — **실려야 하는 사실인데 아직 안 읽는다.** 기준 셋을 다 만족: ① 원본에 읽을 길이\n *                  있다 ② 우리 어휘에 담을 자리가 있다 ③ 아직 안 읽는다. 조치자: **커넥터**.\n *\n *  · `blocked`   — **실려야 하고 담을 자리도 있는데 원본이 읽을 길을 주지 않는다.** 기준: 목록 질의가\n *                  없거나, 있어도 필수 인자 때문에 전역으로 읽을 수 없다. 조치자: **원본 쪽**.\n *                  `todo` 와 한 칸에 두지 않는 이유가 이것이다 — 움직여야 하는 사람이 다르다.\n *\n *  · `no-home`   — **원본에 길은 있는데 그 사실이 상태로 남을 자리가 없다.** 기준은 어휘가 아니라\n *                  **상태에 반영하는 것**이다 — 이벤트 어휘에 통과할 자리가 있어도 상태에 반영되지\n *                  않으면 사실은 남지\n *                  않는다(오히려 더 나쁘다: 검증을 통과하므로 실은 줄 알고 잃는다).\n *                  조치자: **커널·아키텍처** — 반영할 것인지 판단해야 한다.\n *                  냉장 온도가 그 예다. EPCIS `SensorElement`·`sensorReport` 는 이미 있고 검증기도\n *                  본다. **소비하는 곳이 0 이다.** 그러므로 「어휘에 자리가 없다」가 아니라 「상태에\n *                  반영하는 곳이 없다」가 정확하고, 할 일도 자리 만들기가 아니라 그 반영이다.\n *                  **「중요하지 않다」가 아니다.** 오히려 중요한데 못 담는다는 뜻이고, 그래서 판단이\n *                  필요하다. 냉장 온도가 그 예다 — 식품에서 일급 사실인데 계량 어휘가 에너지 전용이다.\n *\n *  · `derived`   — **원본이 다른 표에서 계산해 내놓는 값.** 기준: 그 질의의 결과가 우리가 읽는(또는\n *                  읽을) 사실로부터 계산된다. 읽으면 **같은 수를 두 곳에서 만들게 되고**, 두 수가\n *                  갈리면 어느 것을 믿을지 알 수 없다. 조치자: 없음 — 읽지 않는 것이 정답.\n *\n *  · `duplicate` — **같은 사실을 다른 문으로 내놓는 것.** 기준: 목록 질의로 이미 읽는(또는 읽을) 그\n *                  사실의 단건 드릴다운이다. 계산된 값이 아니므로 `derived` 와 다르고, 관심 밖이\n *                  아니므로 `out-of-scope` 와도 다르다. 조치자: 없음.\n *\n *  · `out-of-scope` — **공장의 상태나 활동이 아니다.** 기준: 그 사실이 자리·물건·설비·사람·작업·\n *                  오더 어디에도 해당하지 않는다(사용자 계정·세무·거래처 마스터). 조치자: 없음.\n *\n * 「읽지 않는다」는 결론은 정당할 수 있다(`derived`·`duplicate`·`out-of-scope`). 결함은 **분류하지\n * 않은 것**이다 — 그것은 생각한 적이 없다는 뜻이다. 그래서 판정은 「전부 읽었나」가 아니라\n * **「전부 판단했나」** 다.\n */\nexport type Disposition = 'read' | 'derived' | 'duplicate' | 'no-home' | 'out-of-scope' | 'blocked' | 'todo'\n\n/** 표면 하나에 대한 판단 — **이유가 필수다.** 이유 없는 분류는 분류한 척이다. */\nexport interface SurfaceRuling {\n  disposition: Disposition\n  /** 왜 그렇게 정했나. 사람이 읽는 한 문장. */\n  why: string\n}\n\nexport interface CoverageInput {\n  /** 원본이 실제로 내놓는 표면 — **원본에서 얻은 것.** 커넥터가 적은 목록이 아니다. */\n  sourceSurface: readonly string[]\n  /** 커넥터의 판단표. */\n  rulings: Readonly<Record<string, SurfaceRuling>>\n}\n\nexport interface CoverageReport {\n  /** 원본 표면 수. */\n  total: number\n  /** 분류된 수. */\n  classified: number\n  /** **분류하지 않은 표면** — 생각한 적 없는 것. 이 목록이 비어야 한다. */\n  unclassified: string[]\n  /** 판단표에는 있는데 원본에 없는 것 — 원본이 바뀌었거나 이름을 잘못 적었다. */\n  stale: string[]\n  byDisposition: Record<Disposition, string[]>\n  /** 실어야 하는데 아직 아닌 것. 초록을 막지는 않지만 **세어 보여야** 한다. */\n  todo: string[]\n  /** 원본이 길을 주지 않아 막힌 것 — 이 목록이 곧 **원본 쪽 선결 과제**다. */\n  blocked: string[]\n}\n\nconst DISPOSITIONS: Disposition[] = ['read', 'derived', 'duplicate', 'no-home', 'out-of-scope', 'blocked', 'todo']\n\nexport function assessCoverage(input: CoverageInput): CoverageReport {\n  const surface = [...new Set(input.sourceSurface)].sort()\n  const byDisposition = DISPOSITIONS.reduce(\n    (acc, d) => ((acc[d] = []), acc),\n    {} as Record<Disposition, string[]>\n  )\n  const unclassified: string[] = []\n\n  for (const name of surface) {\n    const r = input.rulings[name]\n    /* 이유가 없으면 분류로 세지 않는다 — 낱말만 채운 것을 판단으로 세면 이 축이 무의미해진다. */\n    if (!r || !DISPOSITIONS.includes(r.disposition) || !r.why?.trim()) {\n      unclassified.push(name)\n      continue\n    }\n    byDisposition[r.disposition].push(name)\n  }\n\n  const known = new Set(surface)\n  const stale = Object.keys(input.rulings)\n    .filter(k => !known.has(k))\n    .sort()\n\n  return {\n    total: surface.length,\n    classified: surface.length - unclassified.length,\n    unclassified,\n    stale,\n    byDisposition,\n    todo: byDisposition.todo,\n    blocked: byDisposition.blocked\n  }\n}\n\n/**\n * 한 줄 요약 — 화면과 로그가 같은 문장을 쓰도록.\n *\n * **「전부 읽었다」고 말하지 않는다.** 말하는 것은 「전부 판단했다」다. 그리고 분류하지 않은 것이 남아\n * 있으면 그 수를 앞세운다 — 그것이 이 축의 유일한 목적이다.\n */\nexport function coverageLine(r: CoverageReport): string {\n  if (r.unclassified.length) {\n    const head = r.unclassified.slice(0, 5).join(', ')\n    const more = r.unclassified.length > 5 ? ` +${r.unclassified.length - 5}` : ''\n    return `${r.unclassified.length}/${r.total} surface(s) not yet judged — ${head}${more}`\n  }\n  const read = r.byDisposition.read.length\n  const parts = [`${read} read`]\n  if (r.todo.length) parts.push(`${r.todo.length} still to carry`)\n  if (r.blocked.length) parts.push(`${r.blocked.length} blocked at the source`)\n  return `all ${r.total} surface(s) judged; ${parts.join(', ')}`\n}\n"]}

package/dist-server/engine/integration-probes.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-probes.js","sourceRoot":"","sources":["../../server/engine/integration-probes.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;;AAwFH,4CAiBC;AAQD,sCAUC;AAGD,sCAEC;AAnGD;;;;;GAKG;AACU,QAAA,cAAc,GAAyB;IAClD,EAAE,EAAE,EAAE,SAAS,EAAW,KAAK,EAAE,WAAW,EAAI,MAAM,EAAE,eAAe,EAAU,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;IAC9G,EAAE,EAAE,EAAE,UAAU,EAAU,KAAK,EAAE,WAAW,EAAI,MAAM,EAAE,gBAAgB,EAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;IAC9G,EAAE,EAAE,EAAE,QAAQ,EAAY,KAAK,EAAE,WAAW,EAAI,MAAM,EAAE,cAAc,EAAW,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;IAC9G,EAAE,EAAE,EAAE,iBAAiB,EAAG,KAAK,EAAE,WAAW,EAAI,MAAM,EAAE,sBAAsB,EAAG,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAC/G,EAAE,EAAE,EAAE,OAAO,EAAa,KAAK,EAAE,WAAW,EAAI,MAAM,EAAE,aAAa,EAAY,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAC/G,EAAE,EAAE,EAAE,aAAa,EAAO,KAAK,EAAE,MAAM,EAAS,MAAM,EAAE,kBAAkB,EAAO,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;IAC9G,EAAE,EAAE,EAAE,cAAc,EAAM,KAAK,EAAE,MAAM,EAAS,MAAM,EAAE,mBAAmB,EAAM,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAC/G,EAAE,EAAE,EAAE,cAAc,EAAM,KAAK,EAAE,UAAU,EAAK,MAAM,EAAE,oBAAoB,EAAK,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAC/G,EAAE,EAAE,EAAE,UAAU,EAAU,KAAK,EAAE,UAAU,EAAK,MAAM,EAAE,gBAAgB,EAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE;IAC/G,EAAE,EAAE,EAAE,kBAAkB,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,uBAAuB,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE;IAC9G,EAAE,EAAE,EAAE,gBAAgB,EAAI,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,qBAAqB,EAAI,MAAM,EAAE,IAAI,EAAG,MAAM,EAAE,KAAK,EAAE;CAChH,CAAA;AAwBD,MAAM,EAAE,GAAG,CAAC,EAA0B,EAAE,EAAW,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAA;AACjF,6DAA6D;AAC7D;;;GAGG;AACH,MAAM,OAAO,GAAG,CAAC,CAA0B,EAAiB,EAAE,CAC5D,CAAC,EAAE,UAAU,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAA;AACnF,uEAAuE;AACvE,MAAM,aAAa,GAAG,CAAC,CAA0B,EAAU,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;AAE7E;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,OAA+B;IAC9D,OAAO;QACL,aAAa,EAAE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;QACnD,SAAS,EAAE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAC9C,cAAc,EAAE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;QACvD,iDAAiD;QACjD,wBAAwB,EAAE,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,EAAE,UAAU,KAAK,KAAK;QAC9E,eAAe,EAAE,aAAa,CAAC,EAAE,CAAC,OAAO,EAAE,aAAa,CAAC,CAAC;QAC1D,gBAAgB,EAAE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;QACtD,WAAW,EAAE,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,GAAG,KAAK,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,IAAI;QAC9F,YAAY,EAAE,CAAC,GAAG,EAAE;YAClB,MAAM,CAAC,GAAG,EAAE,CAAC,OAAO,EAAE,cAAc,CAAC,CAAA;YACrC,OAAO,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAA;QAC7D,CAAC,CAAC,EAAE;QACJ,iBAAiB,EAAE,EAAE,CAAC,OAAO,EAAE,kBAAkB,CAAC,EAAE,MAAM,KAAK,IAAI;QACnE,wBAAwB,EAAE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,CAAC,CAAC;KACjE,CAAA;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,OAA+B,EAAE,OAAkC,EAAE;IACjG,MAAM,GAAG,GAAc,EAAE,CAAA;IACzB,KAAK,MAAM,IAAI,IAAI,sBAAc,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,SAAQ;QAC9C,MAAM,KAAK,GAAG,EAAE,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC,CAAA;QAClC,IAAI,KAAK,EAAE,UAAU,KAAK,KAAK;YAAE,SAAQ,CAAC,sBAAsB;QAChE,IAAI,CAAC,KAAK,EAAE,GAAG;YAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QAClC,IAAI,IAAI,CAAC,MAAM,IAAI,KAAK,EAAE,GAAG,IAAI,KAAK,CAAC,MAAM,KAAK,KAAK;YAAE,MAAK;IAChE,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED,yDAAyD;AACzD,SAAgB,aAAa,CAAC,OAA+B;IAC3D,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,KAAK,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;AACxH,CAAC","sourcesContent":["/*\n * 연결 적합성 하네스 — **통합을 시험 스위트처럼 돌린다.**\n *\n * 선언 적합성 하네스 세 벌과 같은 규율을 **연결**에 적용한다: 사실이 오류 없이 사라지는 것을 막는다.\n * 다른 점은 대상이 우리 선언이 아니라 **남의 시스템**이라는 것이고, 그래서 두 규칙이 더 붙는다.\n *\n *  ① **돌리지 않은 프로브는 「실패」가 아니라 「모른다」다.** 실패로 처리하면 사람이 그 빨간 칸을\n *     없애려고 무엇이든 하게 되고, 모른다로 처리하면 **무엇을 아직 모르는지**가 남는다. 판정\n *     (`assessStagePath`)이 「모른다」를 달성으로 바꾸지 않으므로 이 구분이 끝까지 살아 있다.\n *  ② **쓰기 프로브는 명시 동의 없이 돌지 않는다.** 이 스위트는 고객의 운영 시스템을 두드린다.\n *     읽기는 기본으로 돌리고, 남의 공장에 명령을 넣는 프로브는 사람이 켜야 돈다 — 켜지 않으면\n *     폐루프 칸은 「검증되지 않음」으로 남는다(그게 사실이다).\n *\n * 순수 모듈이다(전송·DB 무의존). 실행기는 이 선언을 읽어 프로브를 돌리고 `ProbeResult[]` 를 낸다.\n * 화면은 그 결과와 `assessStagePath` 의 판정을 함께 보인다 — 초록/빨강과 **그 초록이 무엇을 증명하나**.\n */\n\nimport type { StageEvidence, StageId } from './stage-path.ts'\n\nexport type ProbeId =\n  | 'connect'            // 붙는다\n  | 'discover'           // 사이트가 열거된다\n  | 'master'             // 구조가 들어온다\n  | 'master-warnings'    // 못 옮긴 값을 세었다\n  | 'items'              // 자리에 물품이 놓인다(비직렬 수량 포함)\n  | 'live-ingest'        // 이벤트가 들어온다\n  | 'live-removal'       // **반출이 관측된다** — 진짜 delta 의 증거\n  | 'declarations'       // 공정 선언이 실려 있다\n  | 'forecast'           // 예측이 돈다\n  | 'actuate-declared'   // 액추에이션 능력이 선언∩구현이다\n  | 'actuate-effect'     // 명령의 효과가 상관되어 돌아온다 (쓰기)\n\nexport interface ProbeSpec {\n  id: ProbeId\n  /** 이 프로브가 증거를 대는 단계. */\n  stage: StageId\n  /** **무엇을 증명하나** — 언어중립 키(사람 말은 표현계층이 렌더). 「무엇을 호출하나」가 아니다. */\n  proves: string\n  /** 대상 시스템을 바꾸는가. 참이면 사람이 켜야 돈다. */\n  writes: boolean\n  /** 이 프로브가 실패하면 뒤 프로브를 돌릴 의미가 없다. */\n  gating: boolean\n}\n\n/**\n * 시퀀스 — 순서가 곧 방법론이다. 앞이 막히면 뒤는 돌리지 않는다(돌려도 답이 무의미하다).\n *\n * `master-warnings` 를 **별개 프로브**로 둔 이유: 구조가 들어오는 것과 못 옮긴 값을 세는 것은 다른\n * 사실이고, 세지 않은 인제스트는 도크를 랙으로 바꿔 놓고도 성공으로 보인다.\n */\nexport const PROBE_SEQUENCE: readonly ProbeSpec[] = [\n  { id: 'connect',          stage: 'structure',   proves: 'probe.connect',         writes: false, gating: true },\n  { id: 'discover',         stage: 'structure',   proves: 'probe.discover',        writes: false, gating: true },\n  { id: 'master',           stage: 'structure',   proves: 'probe.master',          writes: false, gating: true },\n  { id: 'master-warnings',  stage: 'structure',   proves: 'probe.masterWarnings',  writes: false, gating: false },\n  { id: 'items',            stage: 'structure',   proves: 'probe.items',           writes: false, gating: false },\n  { id: 'live-ingest',      stage: 'live',        proves: 'probe.liveIngest',      writes: false, gating: true },\n  { id: 'live-removal',     stage: 'live',        proves: 'probe.liveRemoval',     writes: false, gating: false },\n  { id: 'declarations',     stage: 'forecast',    proves: 'probe.declarations',    writes: false, gating: false },\n  { id: 'forecast',         stage: 'forecast',    proves: 'probe.forecast',        writes: false, gating: false },\n  { id: 'actuate-declared', stage: 'closed-loop', proves: 'probe.actuateDeclared', writes: false, gating: true },\n  { id: 'actuate-effect',   stage: 'closed-loop', proves: 'probe.actuateEffect',   writes: true,  gating: false }\n]\n\n/** 프로브 한 건의 결과. `ran: false` = 돌리지 않았다(실패가 아니다). */\nexport interface ProbeResult {\n  id: ProbeId\n  ran: boolean\n  /**\n   * 이 대상에 **해당하지 않는다**. 통과도 실패도 미측정도 아닌 네 번째 값이다.\n   *\n   * 시뮬레이션 트윈에 라이브 프로브를 들이대면 빨간 칸이 생기는데 그건 결함이 아니다 — 시뮬은 원천에서\n   * 받는 것이 없다. 레퍼런스 없이 템플릿으로 세운 트윈에는 옮겨 온 마스터가 없으므로 「못 옮긴 값」도 없다.\n   * 이걸 통과로 처리하면 없는 능력을 주장하고, 미측정으로 처리하면 영원히 배선을 기다린다.\n   */\n  applicable?: boolean\n  /** 돌렸을 때의 판정. 돌리지 않았으면 무의미하다. */\n  passed?: boolean\n  /** 센 값(자리 수·반출 건수·선언 수 등). 세지 않았으면 없다. */\n  count?: number\n  /** 선언 적재량 프로브만 — `declared`/`total`. */\n  coverage?: { declared: number; total: number }\n  /** 왜 실패했나·왜 건너뛰었나. 언어중립 코드 또는 원문 오류. */\n  detail?: string\n}\n\nconst by = (rs: readonly ProbeResult[], id: ProbeId) => rs.find(r => r.id === id)\n/** 돌렸고 셌으면 그 수, 아니면 `null`(모른다). 실패한 프로브의 수를 0 으로 읽지 않는다. */\n/**\n * 센 값은 **판정과 무관한 사실**이다 — `passed` 를 요구하면 「세어서 0 을 얻었다」가 「모른다」와 구별되지 않는다.\n * 그 구분이 이 하네스의 전부이므로 여기서 잃으면 나머지가 무의미하다. 해당 없음만 `null` 이다.\n */\nconst counted = (r: ProbeResult | undefined): number | null =>\n  r?.applicable === false ? null : r?.ran && r.count !== undefined ? r.count : null\n/** 돌렸고 셌으면 그 수, 아니면 0. **존재 여부**를 묻는 자리에만 쓴다(모름과 0 을 구별할 필요가 없는 축). */\nconst countedOrZero = (r: ProbeResult | undefined): number => counted(r) ?? 0\n\n/**\n * 프로브 결과를 **증거**로 처리한다.\n *\n * 계산 규칙의 정수: **돌리지 않은 프로브는 `null`** 로 간다. 그러면 판정이 그 단계를 달성으로\n * 만들지 않고 `unmeasured` 로 말한다 — 스위트를 절반만 돌리고 초록을 주장할 길이 없다.\n */\nexport function foldProbeResults(results: readonly ProbeResult[]): StageEvidence {\n  return {\n    locationCount: countedOrZero(by(results, 'master')),\n    itemCount: countedOrZero(by(results, 'items')),\n    masterWarnings: counted(by(results, 'master-warnings')),\n    /* 해당 없음은 **미측정이 아니다** — 물을 대상이 아닌 축을 판정에서 뺀다. */\n    masterWarningsApplicable: by(results, 'master-warnings')?.applicable !== false,\n    liveIngestTotal: countedOrZero(by(results, 'live-ingest')),\n    removalsObserved: counted(by(results, 'live-removal')),\n    forecastRan: by(results, 'forecast')?.ran === true && by(results, 'forecast')?.passed === true,\n    specCoverage: (() => {\n      const r = by(results, 'declarations')\n      return r?.ran && r.passed && r.coverage ? r.coverage : null\n    })(),\n    actuateCapability: by(results, 'actuate-declared')?.passed === true,\n    correlatedEffectObserved: counted(by(results, 'actuate-effect'))\n  }\n}\n\n/**\n * 지금 돌릴 프로브 — 게이팅과 쓰기 동의를 지킨다.\n *\n * 앞의 게이팅 프로브가 실패했으면 **거기서 멈춘다.** 뒤를 돌려 빨간 칸을 늘리는 것은 정보를 주지\n * 않는다(원인은 이미 앞에 있다). 쓰기 프로브는 `allowWrites` 없이는 목록에 들어오지 않는다.\n */\nexport function plannedProbes(results: readonly ProbeResult[], opts: { allowWrites?: boolean } = {}): ProbeId[] {\n  const out: ProbeId[] = []\n  for (const spec of PROBE_SEQUENCE) {\n    if (spec.writes && !opts.allowWrites) continue\n    const prior = by(results, spec.id)\n    if (prior?.applicable === false) continue // 해당 없는 프로브는 계획하지 않는다\n    if (!prior?.ran) out.push(spec.id)\n    if (spec.gating && prior?.ran && prior.passed === false) break\n  }\n  return out\n}\n\n/** 해당 없음으로 판정된 프로브 — 화면이 「왜 회색인가」를 말할 수 있게 사유와 함께 낸다. */\nexport function notApplicable(results: readonly ProbeResult[]): { id: ProbeId; detail?: string }[] {\n  return results.filter(r => r.applicable === false).map(r => ({ id: r.id, ...(r.detail ? { detail: r.detail } : {}) }))\n}\n"]}

package/dist-server/engine/integration-runner.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-runner.js","sourceRoot":"","sources":["../../server/engine/integration-runner.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 실행기 — 모은 사실을 프로브 결과로 옮기고, 단계 판정과 프로파일까지 한 번에 낸다.\n *\n * I/O 는 여기 없다(호출자가 모은다). 그래서 판정 전체가 테스트된다.\n */\nimport { PROBE_SEQUENCE, foldProbeResults, notApplicable, plannedProbes, type ProbeId, type ProbeResult } from './integration-probes.ts'\nimport { assessStagePath, forbiddenClaims, type StagePath } from './stage-path.ts'\nimport { narrowProfile, unknownProfile, type FeedKind, type TargetProfile } from './integration-target-profile.ts'\n\n/** 호출자가 모아 오는 사실. 전부 `null` 이 「모른다」다 — 0 이나 false 로 채우지 않는다. */\nexport interface SuiteFacts {\n  /** 이 트윈이 무엇인가. 시뮬은 원천에서 받는 것이 없다(라이브 프로브는 해당 없음). */\n  subject: 'live' | 'sim' | 'stopped' | 'unknown'\n  /** 레퍼런스(원천 어댑터)에서 왔나. 템플릿으로 세운 트윈은 옮겨 온 마스터가 없다. */\n  fromReference: boolean\n  /** `capabilitiesOf(adapter)` — 선언∩구현. */\n  adapterCapabilities: readonly string[]\n  connectOk: boolean | null\n  siteCount: number | null\n  locationCount: number | null\n  itemCount: number | null\n  /** 마지막 동기의 못 옮긴 값 수(`TwinReference.lastWarningCount`). */\n  lastWarningCount: number | null\n  /** 저널 누적 — 재시작에도 남는다(인메모리 계기와 다르다). */\n  journalTotal: number | null\n  /** 저널의 `action='DELETE'` 수 — **반출 관측**. 승격 전 행은 세어지지 않으므로 `null` 이 정직하다. */\n  removalsJournaled: number | null\n  specCoverage: { declared: number; total: number } | null\n  forecastRan: boolean | null\n  feed: FeedKind\n}\n\nexport interface SuiteAssessment {\n  results: ProbeResult[]\n  profile: TargetProfile\n  path: StagePath\n  notApplicable: { id: ProbeId; detail?: string }[]\n  forbiddenClaims: string[]\n  /** 다음에 돌릴 프로브 — 쓰기 동의 없이는 쓰기 프로브가 빠진다. */\n  planned: ProbeId[]\n}\n\nconst r = (id: ProbeId, o: Partial<ProbeResult>): ProbeResult => ({ id, ran: false, ...o })\n\n/** 값이 있으면 돌린 것으로 보고 판정한다. `null` = 안 돌렸다(실패 아님). */\nconst fromNumber = (id: ProbeId, v: number | null, min = 1): ProbeResult =>\n  v === null ? r(id, { ran: false }) : r(id, { ran: true, passed: v >= min, count: v })\n\nexport function assessSuite(f: SuiteFacts, opts: { allowWrites?: boolean } = {}): SuiteAssessment {\n  const liveApplies = f.subject !== 'sim'\n  const results: ProbeResult[] = [\n    f.connectOk === null ? r('connect', { ran: false }) : r('connect', { ran: true, passed: f.connectOk }),\n    fromNumber('discover', f.siteCount),\n    fromNumber('master', f.locationCount),\n    /* 레퍼런스 없이 세운 트윈에는 옮겨 온 마스터가 없다 — 「못 옮긴 값」을 물을 대상이 아니다. */\n    f.fromReference\n      ? fromNumber('master-warnings', f.lastWarningCount, 0)\n      : r('master-warnings', { ran: false, applicable: false, detail: 'not-from-reference' }),\n    fromNumber('items', f.itemCount),\n    liveApplies ? fromNumber('live-ingest', f.journalTotal) : r('live-ingest', { ran: false, applicable: false, detail: 'subject-is-simulation' }),\n    liveApplies ? fromNumber('live-removal', f.removalsJournaled, 1) : r('live-removal', { ran: false, applicable: false, detail: 'subject-is-simulation' }),\n    f.specCoverage === null\n      ? r('declarations', { ran: false })\n      : r('declarations', { ran: true, passed: f.specCoverage.declared > 0, coverage: f.specCoverage }),\n    f.forecastRan === null ? r('forecast', { ran: false }) : r('forecast', { ran: true, passed: f.forecastRan }),\n    r('actuate-declared', { ran: true, passed: f.adapterCapabilities.includes('actuate') }),\n    /* 액추에이션은 계약에 아직 없다(ADR-0036). 측정을 만들면 없는 것을 있는 척한다. */\n    r('actuate-effect', { ran: false, detail: 'actuation-not-wired' })\n  ]\n\n  /* 반출을 셌는데 0 이면 「세지 않음」과 구별해 프로브를 실패로 남긴다 — count 0 은 사실이다. */\n  const removal = results.find(x => x.id === 'live-removal')!\n  if (removal.ran && f.removalsJournaled === 0) removal.count = 0\n\n  const profile = narrowProfile(unknownProfile(), {\n    feed: f.feed,\n    multiSite: f.siteCount === null ? null : f.siteCount > 1,\n    write: f.adapterCapabilities.includes('actuate') ? 'command' : 'unknown'\n  })\n\n  const evidence = { ...foldProbeResults(results), subject: liveApplies ? ('live' as const) : ('sim' as const), feed: f.feed }\n  const path = assessStagePath(evidence)\n\n  return {\n    results,\n    profile,\n    path,\n    notApplicable: notApplicable(results),\n    forbiddenClaims: forbiddenClaims(path),\n    planned: plannedProbes(results, opts)\n  }\n}\n\n/** 시퀀스 명세 — 화면이 회색 칸의 이유(해당 없음·미실행)를 나란히 보이도록 함께 낸다. */\nexport const SUITE_SPEC = PROBE_SEQUENCE\n"]}

package/dist-server/engine/integration-target-profile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integration-target-profile.js","sourceRoot":"","sources":["../../server/engine/integration-target-profile.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;GAeG;;AA8CH,wCAEC;AAGD,8BAKC;AAQD,sCAUC;AAQD,oCAKC;AA1CD,mCAAmC;AACnC,SAAgB,cAAc;IAC5B,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,CAAA;AAClJ,CAAC;AAED,wCAAwC;AACxC,SAAgB,SAAS,CAAC,CAAgB,EAAE,IAAyB;IACnE,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAA;IACjB,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAC3C,IAAI,IAAI,KAAK,WAAW;QAAE,OAAQ,CAAyB,CAAC,MAAM,KAAK,CAAC,CAAA;IACxE,OAAO,CAAC,KAAK,SAAS,CAAA;AACxB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,IAAmB,EAAE,KAA6B;IAC9E,MAAM,GAAG,GAAkB,EAAE,GAAG,IAAI,EAAE,CAAA;IACtC,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAA4B,EAAE,CAAC;QAC9D,MAAM,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QAClB,IAAI,CAAC,KAAK,SAAS;YAAE,SAAQ;QAC7B,IAAI,CAAC,KAAK,WAAW,EAAE,CAAC;YAAC,IAAI,CAAC,KAAK,IAAI;gBAAE,GAAG,CAAC,SAAS,GAAG,CAAY,CAAC;YAAC,SAAQ;QAAC,CAAC;QACjF,IAAI,CAAC,KAAK,WAAW,EAAE,CAAC;YAAC,MAAM,IAAI,GAAG,CAAwB,CAAC;YAAC,IAAI,IAAI,CAAC,MAAM;gBAAE,GAAG,CAAC,SAAS,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC,GAAG,GAAG,CAAC,SAAS,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAAC,SAAQ;QAAC,CAAC;QACtJ,IAAI,CAAC,KAAK,SAAS;YAAG,GAAW,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;IAC1C,CAAC;IACD,OAAO,GAAG,CAAA;AACZ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,CAAgB;IAC3C,IAAI,CAAC,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,CAAA;IACtE,IAAI,CAAC,CAAC,IAAI,KAAK,MAAM;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,CAAA;IAC9D,IAAI,CAAC,CAAC,IAAI,KAAK,eAAe;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,oBAAoB,EAAE,CAAA;IAClF,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAA;AACrB,CAAC","sourcesContent":["/*\n * 대상 프로파일 — **스위트가 갈리는 근거.**\n *\n * ── 왜 프로파일이 먼저인가 ──────────────────────────────────────────────────\n * 처음 만든 시퀀스는 직선이었다. 모든 대상에게 같은 순서를 강요했고, 그래서 두 방향으로 거짓말을\n * 했다: push 소스에 커서 프로브를 들이대 빨간 칸을 만들고(결함이 아닌데), 반대로 스냅샷 소스에는\n * 반출을 못 본 이유를 「아직 안 돌렸다」로 적었다(구조적으로 못 내는 것인데).\n *\n * 갈림의 근거는 **대상의 성격**이고, 그 성격은 **우리가 정하는 것이 아니라 발견하는 것**이다.\n * 그래서 프로파일의 모든 축은 `'unknown'` 에서 시작해 프로브가 좁힌다. 모르는 축으로는 라우팅하지\n * 않는다 — 모르면 그 축에 걸린 프로브는 「아직 판단할 수 없음」이고, 짐작으로 건너뛰지 않는다.\n *\n * ── 축을 고른 기준 ─────────────────────────────────────────────────────────\n * 실제로 **다른 프로브를 요구하는 것만** 축이 된다. 「벤더 이름」은 축이 아니다(같은 벤더가 REST 도\n * 파일도 준다). 아래 일곱은 각각 적어도 한 프로브의 적용 여부를 바꾼다.\n */\n\n/** 무엇으로 붙나 — 페이지·상한·질의 형태가 여기서 갈린다. */\nexport type Transport = 'rest' | 'graphql' | 'db' | 'file' | 'mqtt' | 'opc' | 'unknown'\n\n/**\n * 변화를 어떻게 아나 — **라이브 단계의 성격이 통째로 이 축에 달려 있다.**\n *\n *  · `push`          원천이 밀어 준다(구독·웹훅·큐·CDC). 커서가 필요 없다.\n *  · `delta-poll`    거래 이력을 커서로 읽는다. **커서 정합이 급소다.**\n *  · `snapshot-poll` 현재 상태를 되풀어 읽는다. **반출을 원리적으로 낼 수 없다** — 라이브 단계는\n *                    「아직」이 아니라 **구조적으로 불가**이고, 그 사실을 그대로 말한다.\n *  · `none`          변화를 알 길이 없다(구조 전용 소스).\n */\nexport type FeedKind = 'push' | 'delta-poll' | 'snapshot-poll' | 'none' | 'unknown'\n\n/** 물건을 무엇이라 부르나 — 발명해야 하는지가 여기서 갈린다. */\nexport type IdentityKind = 'gs1' | 'local' | 'none' | 'unknown'\n\n/**\n * 양을 어떻게 세나 — **개수냐 연속량이냐.**\n *\n * 식품·화학·제약은 KG·L 로 오고, 조립 제조는 대수로 온다. 커널·미러는 둘 다 다루지만(비직렬\n * `MaterialSubLot`), **요구하는 프로브가 다르다**: 연속량이면 단위 어휘와 환산을 반드시 묻고,\n * 직렬이면 그 프로브는 해당 없음이다.\n */\nexport type Quantization = 'serial' | 'continuous' | 'mixed' | 'unknown'\n\n/** 이 원천이 겸하는 버티컬 — 둘 이상이면 트윈이 여럿이고 **핸드오버 경계**를 물어야 한다. */\nexport type Vertical = 'wms' | 'mes' | 'yms' | 'ems'\n\n/** 밖으로 나가는 문 — 폐루프 프로브의 적용 여부. */\nexport type WriteSurface = 'none' | 'command' | 'unknown'\n\nexport interface TargetProfile {\n  transport: Transport\n  feed: FeedKind\n  multiSite: boolean | null\n  identity: IdentityKind\n  quantization: Quantization\n  /** 빈 배열 = 아직 모른다(없다는 뜻이 아니다). */\n  verticals: readonly Vertical[]\n  write: WriteSurface\n}\n\n/** 아무것도 모르는 상태 — 스위트는 여기서 시작한다. */\nexport function unknownProfile(): TargetProfile {\n  return { transport: 'unknown', feed: 'unknown', multiSite: null, identity: 'unknown', quantization: 'unknown', verticals: [], write: 'unknown' }\n}\n\n/** 이 축을 아직 모르나 — 모르는 축으로는 라우팅하지 않는다. */\nexport function isUnknown(p: TargetProfile, axis: keyof TargetProfile): boolean {\n  const v = p[axis]\n  if (axis === 'multiSite') return v === null\n  if (axis === 'verticals') return (v as readonly Vertical[]).length === 0\n  return v === 'unknown'\n}\n\n/**\n * 프로브가 알아낸 것을 프로파일에 반영한다 — **좁히기만 한다.**\n *\n * 이미 알아낸 축을 나중 프로브가 `'unknown'` 으로 덮지 못하게 한다. 스위트는 여러 번 돌고, 뒤에\n * 돌린 프로브가 그 축을 다루지 않는다는 이유로 앞의 발견을 지우면 라우팅이 왕복한다.\n */\nexport function narrowProfile(base: TargetProfile, found: Partial<TargetProfile>): TargetProfile {\n  const out: TargetProfile = { ...base }\n  for (const k of Object.keys(found) as (keyof TargetProfile)[]) {\n    const v = found[k]\n    if (v === undefined) continue\n    if (k === 'multiSite') { if (v !== null) out.multiSite = v as boolean; continue }\n    if (k === 'verticals') { const list = v as readonly Vertical[]; if (list.length) out.verticals = [...new Set([...out.verticals, ...list])]; continue }\n    if (v !== 'unknown') (out as any)[k] = v\n  }\n  return out\n}\n\n/**\n * 이 프로파일에서 **라이브가 구조적으로 가능한가.**\n *\n * `snapshot-poll` 은 불가다 — 사라진 것은 그냥 없어지고 `OBSERVE` 만 남는다. 이걸 「아직 반출을 못\n * 봤다」로 적으면 사람이 더 기다리게 되는데, 더 기다려도 오지 않는다. 방식을 바꿔야 한다는 것이 답이다.\n */\nexport function liveFeasible(p: TargetProfile): { ok: boolean; reason?: string } {\n  if (p.feed === 'unknown') return { ok: false, reason: 'feed-unknown' }\n  if (p.feed === 'none') return { ok: false, reason: 'no-feed' }\n  if (p.feed === 'snapshot-poll') return { ok: false, reason: 'snapshot-only-feed' }\n  return { ok: true }\n}\n"]}

package/dist-server/engine/kpi-baseline.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"kpi-baseline.js","sourceRoot":"","sources":["../../server/engine/kpi-baseline.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 여러 구간 동시 비교 — **\"어제보다 나아졌다\" 를 넘어선다.** 순수.\n *\n * ── 왜 필요한가 (성과 맵 ③) ─────────────────────────────────────────────────\n * 지금 비교 축은 **한 구간**만 본다(직전 구간 또는 하루 전). 그래서 판단이 딱 한 문장에서 멈춘다:\n * \"어제보다 나아졌다.\" **어제도 나빴으면 그 말은 쓸모가 없다.** 목표(`kpi-target`)가 그 한계를 한쪽에서\n * 풀지만, 목표를 아직 걸지 않은 현장은 여전히 자기 숫자가 평소와 같은지도 알 수 없다.\n *\n * 최근 며칠의 **같은 시간대**를 함께 계산하면 목표 없이도 말할 수 있다 — \"오늘 이 시간대는 지난 7일 중\n * 가장 낮다.\" 그것이 이 파일이 만드는 것이다: 창 여러 개의 **분포**와 그 안에서 현재의 **자리**.\n *\n * ── 이 파일이 하지 않는 것 ──────────────────────────────────────────────────\n * · **지표 어휘를 모른다.** 이름·방향·값 꺼내는 법은 `kpi-target.ts` 의 `TWIN_METRIC` 이 소유한다. 여기는\n *   **이미 꺼낸 값**만 받는다 — 어휘가 두 곳에 생기면 그 사이에 매핑 표가 자라고 그것이 곧 방언이다.\n *   (덤으로: 이 모듈은 런타임 import 가 없어 테스트가 소스를 그대로 든다.)\n * · **DB·조회를 모른다.** 창 목록만 계산하고, 그 창을 읽는 것은 호출부의 일이다.\n * · **좋고 나쁨의 임계를 발명하지 않는다.** \"평소보다 나쁘다\" 는 중앙값과의 비교로만 말한다 — 임의의\n *   퍼센트 임계를 두면 그 숫자가 곧 숨은 목표가 된다.\n *\n * ── 정직성 규율 (이 도메인의 핵심) ──────────────────────────────────────────\n *  ① **결측 창을 알리지 않고 빼지 않는다.** 요청한 창 전부를 `measured` 와 함께 돌려주고, 분포는 측정된\n *     것만으로 만든다. 빼고 말하면 \"지난 7일\" 이 실제로는 3일이었다는 것을 아무도 모른다.\n *  ② **표본이 둘 미만이면 자리를 말하지 않는다.** 하나를 분포라 부를 수 없다.\n *  ③ **현재 값이 없으면 자리를 말하지 않는다.** 결측을 0 으로 읽으면 시간 지표는 \"낮을수록 좋다\" 라서\n *     **일이 없던 구간이 최고 성적**으로 보고된다(목표 판정에서 이미 겪은 결함이다).\n *  ④ 왜 말하지 않는지를 `reason` 으로 밝힌다 — 알리지 않고 빈 값을 주면 화면이 \"분포 없음\" 을 \"평범함\" 으로\n *     그린다.\n */\n\n/** 창 하나 — 폴드의 창과 같은 모양(ms). */\nexport interface BaselineWindow {\n  fromMs: number\n  toMs: number\n}\n\n/** 며칠 전 같은 시간대인가, 몇 주 전 같은 요일·시간대인가. */\nexport type BaselineStride = 'day' | 'week'\n\n/** 한 번에 볼 수 있는 과거 구간 수 — 창마다 조회가 한 번 더 붙으므로 상한을 둔다. */\nexport const MAX_BASELINE_PERIODS = 14\n\nconst MS_DAY = 24 * 60 * 60_000\n\n/**\n * 비교할 과거 창들 — 현재 창을 **같은 길이로** 하루(또는 한 주)씩 뒤로 옮긴다.\n *\n * 가까운 것부터 준다(어제 → 그제 → …). 화면이 시간 순서를 다시 정하지 않아도 되게.\n *\n * **한계를 밝힌다**: 옮기는 것은 ms 산술이다. 트윈 공간은 고정 오프셋(`utcOffsetMinutes`)을 선언하므로\n * 현재 모델에서는 \"같은 시간대\" 가 정확하다. 일광절약시간을 쓰는 시간대를 나중에 지원하면 전환이 있는\n * 주의 하루가 한 시간 밀린다 — 그때는 오프셋 기준 캘린더 산술로 바꿔야 한다(지금 지어내지 않는다).\n */\nexport function baselineWindows(\n  fromMs: number,\n  toMs: number,\n  periods: number,\n  stride: BaselineStride = 'day'\n): BaselineWindow[] {\n  if (!Number.isFinite(fromMs) || !Number.isFinite(toMs) || toMs <= fromMs) return []\n  const count = Math.max(0, Math.min(MAX_BASELINE_PERIODS, Math.floor(periods)))\n  const step = stride === 'week' ? 7 * MS_DAY : MS_DAY\n\n  return Array.from({ length: count }, (_, i) => ({\n    fromMs: fromMs - step * (i + 1),\n    toMs: toMs - step * (i + 1)\n  }))\n}\n\n/** 지표의 성질 — 이름과 값 꺼내기는 호출부(`TWIN_METRIC`)가 소유한다. */\nexport interface MetricSpecLike {\n  direction: 'higher' | 'lower'\n  unit: string\n}\n\n/** 과거 창 하나에서 꺼낸 값들 — 그 창에 기록이 없으면 값이 `undefined` 다. */\nexport interface BaselineSampleInput<M extends string> {\n  fromMs: number\n  toMs: number\n  values: Partial<Record<M, number | undefined>>\n}\n\n/** 과거 창 하나의 결과 — **결측도 남긴다**(빼면 \"지난 7일\" 이 거짓이 된다). */\nexport interface BaselineSample {\n  fromMs: number\n  toMs: number\n  measured: boolean\n  value?: number\n}\n\n/** 왜 자리를 말하지 않는지. */\nexport type BaselineNoPosition = 'no-current' | 'too-few-samples'\n\n/**\n * 분포 안에서 현재의 자리 — **방향을 적용한 읽기.**\n *\n * 임의의 임계가 없다: 표본 전부보다 좋으면 `best`, 전부보다 나쁘면 `worst`, 그 사이는 중앙값을 기준으로\n * 구분한다. `typical` 은 중앙값과 **같을 때**만이다.\n */\nexport type BaselineStanding = 'best' | 'better-than-typical' | 'typical' | 'worse-than-typical' | 'worst'\n\nexport interface MetricBaseline<M extends string = string> {\n  metric: M\n  direction: 'higher' | 'lower'\n  unit: string\n  /** 지금 창의 값 — 없으면 `undefined`(0 이 아니다). */\n  current?: number\n  /** 요청한 과거 창 전부(결측 포함, 가까운 것부터). */\n  samples: BaselineSample[]\n  /** 요청한 창 수 / 그중 실제로 측정된 수 — 둘을 함께 봐야 \"지난 7일\" 을 믿을 수 있다. */\n  requested: number\n  measuredCount: number\n  /** 측정된 표본만의 요약. 표본이 없으면 전부 `undefined`. */\n  min?: number\n  median?: number\n  max?: number\n  /** 측정 표본을 오름차순으로 놓았을 때 현재 값이 몇 번째인가(1 = 가장 작음) — **방향 없는 사실**. */\n  rank?: number\n  /** 그 순위를 셀 때의 표본 수(+현재 1). 순위만 보면 표본이 둘이었는지 열이었는지 알 수 없다. */\n  rankOf?: number\n  /** 방향을 적용한 읽기. 말할 수 없으면 없다. */\n  standing?: BaselineStanding\n  /** 자리를 말하지 않은 이유. */\n  noPosition?: BaselineNoPosition\n}\n\n/** 중앙값 — 짝수 개면 가운데 둘의 평균(폴드의 분위수 규약과 달리 여기 표본은 아주 작다). */\nfunction medianOf(sorted: readonly number[]): number | undefined {\n  if (!sorted.length) return undefined\n  const mid = sorted.length >> 1\n  return sorted.length % 2 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2\n}\n\n/**\n * 지표별로 분포와 자리를 만든다.\n *\n * @param specs   지표 성질(방향·단위). 열거된 지표만 낸다 — 모르는 이름을 짐작하지 않는다.\n * @param current 지금 창에서 꺼낸 값들(결측은 `undefined`).\n * @param inputs  과거 창들에서 꺼낸 값들(가까운 것부터).\n */\nexport function summarizeBaseline<M extends string>(\n  specs: Readonly<Record<M, MetricSpecLike>>,\n  current: Partial<Record<M, number | undefined>>,\n  inputs: readonly BaselineSampleInput<M>[]\n): MetricBaseline<M>[] {\n  const out: MetricBaseline<M>[] = []\n\n  for (const metric of Object.keys(specs) as M[]) {\n    const spec = specs[metric]\n    const samples: BaselineSample[] = inputs.map(s => {\n      const v = s.values[metric]\n      const measured = typeof v === 'number' && Number.isFinite(v)\n      return measured ? { fromMs: s.fromMs, toMs: s.toMs, measured: true, value: v as number } : { fromMs: s.fromMs, toMs: s.toMs, measured: false }\n    })\n\n    const values = samples.filter(s => s.measured).map(s => s.value as number)\n    const sorted = [...values].sort((a, b) => a - b)\n    const cur = current[metric]\n    const hasCurrent = typeof cur === 'number' && Number.isFinite(cur)\n\n    const row: MetricBaseline<M> = {\n      metric,\n      direction: spec.direction,\n      unit: spec.unit,\n      ...(hasCurrent ? { current: cur as number } : {}),\n      samples,\n      requested: inputs.length,\n      measuredCount: values.length,\n      ...(sorted.length ? { min: sorted[0], median: medianOf(sorted), max: sorted[sorted.length - 1] } : {})\n    }\n\n    /* 자리를 말할 수 없는 두 경우 — 이유를 밝힌다(들어온 것이 없는 빈 값이 \"평범함\" 으로 읽힌다). */\n    if (!hasCurrent) row.noPosition = 'no-current'\n    else if (sorted.length < 2) row.noPosition = 'too-few-samples'\n    else {\n      const value = cur as number\n      const median = medianOf(sorted) as number\n      /* 오름차순에서 몇 번째인가 — 같은 값은 뒤에 놓는다(동률이면 \"더 큰 쪽\" 으로 세지 않는다). */\n      row.rank = sorted.filter(v => v < value).length + 1\n      row.rankOf = sorted.length + 1\n\n      const higherIsBetter = spec.direction === 'higher'\n      const beatsAll = higherIsBetter ? value > sorted[sorted.length - 1] : value < sorted[0]\n      const losesToAll = higherIsBetter ? value < sorted[0] : value > sorted[sorted.length - 1]\n      /* 중앙값보다 큰 것이 \"좋은\" 쪽인가 — 방향을 여기 한 번만 적용한다. */\n      const aboveMedianIsBetter = higherIsBetter === value > median\n\n      row.standing = beatsAll\n        ? 'best'\n        : losesToAll\n          ? 'worst'\n          : value === median\n            ? 'typical'\n            : aboveMedianIsBetter\n              ? 'better-than-typical'\n              : 'worse-than-typical'\n    }\n\n    out.push(row)\n  }\n\n  return out\n}\n"]}