@things-factory/headless-twin 10.0.18 → 10.1.0

package/dist-server/engine/ingest-dedupe.d.ts

@@ -1,9 +1,5 @@
-/**
- * 이 봉투가 말하는 사실의 정체 — 같으면 같은 사실이다.
- *
- * 대상이나 시각을 알 수 없으면 **정체를 만들지 않는다**(`undefined`). 그때는 거르지 않고 통과시킨다 —
- * 모르는 것을 같다고 판단하면 서로 다른 사실이 하나로 합쳐진다. 알리지 않고 잃는 것보다 두 번 세는 것이 낫다.
- */
+/** 지금까지 정체를 못 만든 것 — 종류별. 읽고 비운다. */
+export declare function takeUnidentified(): Record<string, number>;
 export declare function factIdentity(envelope: any): string | undefined;
 /**
  * 최근에 본 정체를 기억한다 — **크기에 상한을 둔다.**
@@ -21,6 +17,22 @@ export declare class FactDeduper {
     static WINDOW: number;
     private seen;
     private order;
+    /**
+     * 이미 아는 것으로 **미리 기억한다** — 저널에서 읽어 채울 때.
+     *
+     * ── 왜 필요한가 (2026-09-06 측정) ─────────────────────────────────────────
+     * 이 기억은 프로세스 안에만 있다. 재기동하면 비워지고, 그 뒤 backfill 을 돌리면 **이미 저널에
+     * 있는 사실도 「처음 본 것」**이 된다.
+     *
+     * 실제로 그랬다. `mes-line-a` 를 재기동 뒤 backfill 하니 39건이 전부 다시 앉아 저널이
+     * 44 → 83건이 되고 44가지가 중복이 됐다.
+     *
+     * push 경로에서는 안 보인다. 재전송이 몇 분 안에 오므로 창 안에서 걸린다. **backfill 이 그 전제를
+     * 깬다** — 몇 달 전 사실을 지금 받으니 재기동 한 번이면 그 구간이 통째로 다시 앉는다.
+     *
+     * 그래서 backfill 이 부르기 전에 그 구간의 정체를 저널에서 읽어 여기 넣는다.
+     */
+    remember(identities: readonly string[]): number;
     /** 이 사실을 본 적이 있나 — 없으면 기억하고 `false`. */
     private known;
     /**

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

@@ -37,6 +37,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FactDeduper = void 0;
+exports.takeUnidentified = takeUnidentified;
 exports.factIdentity = factIdentity;
 /** 시각을 밀리초로 — 연결된 시스템이 준 시각이 먼저, 없으면 봉투의 시각. */
 function timeOf(envelope) {
@@ -48,22 +49,158 @@ function timeOf(envelope) {
     return undefined;
 }
 /**
- * 이 봉투가 말하는 대상 — 어휘마다 이름이 다르므로 아는 이름을 모두 본다.
+ * 이 봉투가 말하는 것을 **가르는 값들** — 하나라도 다르면 다른 사실이다.
  *
- * 순서가 뜻을 갖는다: 주체를 먼저 본다. 설비 사실은 「지금 붙어 있는 작업」을 함께 싣고, 작업 사실은
- * 「소속 오더」를 함께 싣는다. 아무 이름이나 먼저 보면 참조를 주체로 읽는다(승격 키에서 겪은 것과 같다).
+ * ── 예전에는 하나만 골랐다 (2026-09-05 실측) ───────────────────────────────
+ * 아는 이름을 순서대로 보고 **먼저 걸리는 하나**를 대상으로 삼았다. 「주체를 먼저 본다」는 판단
+ * 자체는 옳다 — 설비 사실은 「지금 붙어 있는 작업」을 참조로 싣는다. 그런데 **고르고 나머지를
+ * 버린 것**이 결함이었다.
+ *
+ * 실제로 난 일: plant 이 실적 둘을 보냈는데 한 건이 저널에 안 남았다.
+ *
+ *   seq 36   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-01 · goodCount 12
+ *   seq 41   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-02 · goodCount  9
+ *
+ * 두 실적의 시각이 같았고(원본이 끝시각을 복사) `moverId` 가 `taskId` 보다 먼저라 **둘이 한 사실이
+ * 됐다.** 거부가 아니라 되풀이로 세어졌다 — `offered 5 · rejected 0 · journaled 3`.
+ *
+ * **구별할 값이 이미 봉투 안에 있었는데 판정이 그것을 안 봤다.**
+ *
+ * ── 그리고 EPCIS 도 같았다 ─────────────────────────────────────────────────
+ * 저널 246만 건에 현재 규칙을 다시 걸어 보니 겹치는 묶음이 여섯이었고, 전부 이 모양이다.
+ *
+ *   같은 EPC · 같은 밀리초
+ *     ① bizStep receiving      action ADD      disposition sellable_accessible
+ *     ② bizStep commissioning  action OBSERVE  disposition reserved
+ *
+ * **한 개체의 서로 다른 관측**이다. EPCIS 에서 이상한 일이 아닌데 규칙이 그 셋을 안 봤다.
+ *
+ * ── 왜 넓히는 쪽이 맞나 ────────────────────────────────────────────────────
+ * 이 파일이 스스로 적어 둔 값이 그것이다 — 「알리지 않고 잃는 것보다 두 번 세는 것이 낫다」.
+ * 지금 거동은 **알리지 않고 잃는 쪽**이었다.
+ *
+ * 넓혀도 되풀이는 그대로 걸린다: 같은 봉투를 다시 보내면 **이 값들이 전부 같다.** 넓히는 것은
+ * 「다른 사실을 합치지 않는다」만 강해지고 「되풀이를 잡는다」는 안 약해진다.
  */
-function targetOf(envelope) {
+function discriminatorsOf(envelope) {
     const d = envelope?.data ?? {};
-    const first = (...vals) => {
-        for (const v of vals) {
-            const s = String(v ?? '').trim();
-            if (s)
-                return s;
-        }
-        return undefined;
+    const out = [];
+    const put = (name, v) => {
+        const t = String(v ?? '').trim();
+        if (t)
+            out.push(`${name}=${t}`);
     };
-    return first(d.meterId, d.equipmentId, d.moverId, d.taskId, d.orderId, d.personId, d.assetId, d.locationId, d.epcList?.[0], d.parentID, d.quantityList?.[0]?.epcClass, d.transformationID);
+    /*
+     * 주체·참조를 **다 적는다.** 순서는 값이 아니라 이름으로 고정되므로 봉투마다 흔들리지 않는다.
+     *
+     * ⚠ **이 목록은 계약의 `identity` 선언을 손으로 옮긴 것이다.** 계약이 kind 마다 무엇이 그 사실을
+     * 가리키는지 이미 선언하는데(`operational-ingest.ts` 의 `SPECS[kind].identity`), 그것을 내보내지
+     * 않아서 여기가 따로 들고 있다.
+     *
+     * 그래서 새 kind 가 생기면 여기가 조용히 뒤처진다. 실제로 두 번 그랬다 — `subjectId`(처분)와
+     * `testableObjectId`(시험)가 빠져 있었고, 그동안 그 두 종류는 정체를 못 만들거나 서로 다른 사실이
+     * 뭉칠 수 있었다.
+     *
+     * 계약이 `operationalIdentityField(kind)` 를 내보내면 이 목록을 지운다. 그 문을 열어 두었고
+     * 배포를 기다린다.
+     */
+    put('meter', d.meterId);
+    put('equipment', d.equipmentId);
+    put('mover', d.moverId); // vocabulary-guard: allow — 봉투의 옛 세대 필드 이름(저장된 계약)
+    put('task', d.taskId);
+    put('order', d.orderId);
+    put('person', d.personId);
+    put('asset', d.assetId);
+    put('location', d.locationId); // vocabulary-guard: allow — 같음
+    put('epc', d.epcList?.[0]);
+    put('parent', d.parentID);
+    put('class', d.quantityList?.[0]?.epcClass);
+    put('transformation', d.transformationID);
+    /*
+     * ── 주체가 `subjectId` 인 사실이 있다 (2026-09-06 측정) ──────────────────────
+     * 부적합 처분과 시험 결과는 **표준 `TestableObjectID` 와 같은 자리**를 쓴다(로트 · 설비 · 자리에
+     * 두루 쓰는 하나의 이름). 그 이름이 여기 없어서 두 종류가 **정체를 못 만들었다** —
+     * `parts` 가 비면 `factIdentity` 가 `undefined` 를 내고, 그러면 dedupe 밖이다.
+     *
+     * 실제로 그랬다. `fillTwinScope` 를 두 번 돌릴 때마다 그 둘이 7건씩 다시 앉았다(처분 4 · 시험 3).
+     * 나머지 34건은 걸러졌는데 이 둘만 계속 늘었다.
+     */
+    put('subject', d.subjectId);
+    put('spec', d.specId);
+    /*
+     * 시험 결과의 주체는 `testableObjectId` 다 — 표준 `TestableObjectID` 의 이름을 그대로 쓴다.
+     *
+     * 이 이름이 없어서 **같은 명세로 같은 시각에 잰 서로 다른 로트가 한 사실로 뭉쳤다.** 중복이 생기는
+     * 것보다 나쁘다 — 두 로트의 시험 결과 중 하나가 사라진다.
+     *
+     * 실제로 `mes-miratek` 에 같은 시험 결과가 10건 있었다(2026-09-06 확인). 그것은 뭉친 것이 아니라
+     * 반대로 dedupe 를 못 지난 것인데, 같은 자리에서 뭉치는 쪽도 열려 있었다.
+     */
+    put('object', d.testableObjectId);
+    /* 완료 선언의 주체 — 「이 축은 여기까지가 전부다」를 말하는 축 이름. */
+    put('axis', d.completeAxis);
+    /*
+     * EPCIS 는 「무엇을 말하는 관측인가」가 이 셋으로 갈린다. 한 개체가 한 순간에 두 관측을 갖는
+     * 것은 표준에서 정상이고, 이것을 안 보면 뒤엣것이 사라진다.
+     */
+    put('bizStep', d.bizStep);
+    put('action', d.action);
+    put('disposition', d.disposition);
+    /*
+     * ── 변환은 **무엇이 무엇으로 되었나**로 갈린다 (2026-09-07 측정) ─────────────
+     * 이 자리가 없어서 **사실 하나가 없어졌습니다.** 거절이 아니라 되풀이로 세어져서 경고도 없었습니다.
+     *
+     * ```
+     * plant outbox seq 37   in LOT-CT-SIDE-001 24개  →  out LOT-CT-MAIN-003 12개
+     * plant outbox seq 42   in LOT-CT-SIDE-001 18개  →  out LOT-CT-MAIN-004  9개
+     *                       transformationID · bizStep · 초까지 전부 같다
+     * 저널에 남은 것        LOT-CT-MAIN-003 하나
+     * ```
+     *
+     * `LOT-CT-MAIN-004` 를 어느 패널로 만들었는지 트윈이 답하지 못하는 상태였습니다.
+     *
+     * 그리고 **구별할 값이 봉투 안에 이미 있었습니다** — `outputQuantityList[0].epcClass` 가 서로
+     * 다릅니다. 이 파일 머리말이 적어 둔 그 모양 그대로입니다: 판정이 그것을 안 봤습니다.
+     *
+     * 산출만 보지 않고 **입력도 봅니다.** 같은 로트를 같은 초에 두 번 소비하면서 산출 이름이 같은
+     * 경우(수량만 다른 분할)가 남고, 그때 입력 수량이 유일한 차이입니다. 수량까지 넣는 이유가 그것입니다.
+     */
+    put('inClass', classOf(d.inputQuantityList));
+    put('inEpc', d.inputEPCList?.[0]);
+    put('inQty', qtyOf(d.inputQuantityList));
+    put('outClass', classOf(d.outputQuantityList));
+    put('outEpc', d.outputEPCList?.[0]);
+    put('outQty', qtyOf(d.outputQuantityList));
+    /*
+     * 담김의 자식도 같은 이유로 본다 — 한 팔레트에 서로 다른 묶음을 같은 초에 두 번 실으면 뒤엣것이
+     * 사라진다. 위 변환에서 실제로 그렇게 잃었으니 여기도 함께 막는다(한 종류만 고치면 나머지에 남는다).
+     */
+    put('childEpc', d.childEPCs?.[0]);
+    put('childClass', classOf(d.childQuantityList));
+    put('childQty', qtyOf(d.childQuantityList));
+    /*
+     * 어느 오더의 사실인가도 정체의 일부다. 같은 공정을 같은 초에 두 오더로 돌리는 것은 정상이고,
+     * 이것을 안 보면 뒤엣것이 사라진다.
+     */
+    put('tx', d.bizTransactionList?.[0]?.bizTransaction);
+    return out;
+}
+/** 수량 목록의 첫 종류 — 목록이 비면 `undefined`(빈 문자열을 넣지 않는다). */
+function classOf(list) {
+    const first = Array.isArray(list) ? list[0] : undefined;
+    const v = first?.epcClass;
+    return typeof v === 'string' && v.trim() ? v : undefined;
+}
+/**
+ * 수량 목록을 수까지 적는다 — 종류가 같고 수량만 다른 사실을 가른다.
+ *
+ * 목록 전체를 적는다. 첫 원소만 보면 「같은 것 둘 + 다른 것 하나」가 첫 원소로는 구별되지 않는다.
+ */
+function qtyOf(list) {
+    if (!Array.isArray(list) || !list.length)
+        return undefined;
+    const parts = list.map((x) => `${x?.epcClass ?? ''}:${x?.quantity ?? ''}${x?.uom ? '/' + x.uom : ''}`);
+    return parts.join('|');
 }
 /**
  * 이 봉투가 말하는 사실의 정체 — 같으면 같은 사실이다.
@@ -71,17 +208,42 @@ function targetOf(envelope) {
  * 대상이나 시각을 알 수 없으면 **정체를 만들지 않는다**(`undefined`). 그때는 거르지 않고 통과시킨다 —
  * 모르는 것을 같다고 판단하면 서로 다른 사실이 하나로 합쳐진다. 알리지 않고 잃는 것보다 두 번 세는 것이 낫다.
  */
+/**
+ * 정체를 못 만든 사실을 **종류별로** 센다 — dedupe 밖으로 나간 것들.
+ *
+ * 이 수가 0이 아니면 그 종류는 다시 받을 때마다 저널에 다시 앉는다. 그 종류의 주체 이름을
+ * `discriminatorsOf` 에 더해야 한다.
+ */
+const unidentified = {};
+/** 지금까지 정체를 못 만든 것 — 종류별. 읽고 비운다. */
+function takeUnidentified() {
+    const out = { ...unidentified };
+    for (const k of Object.keys(unidentified))
+        delete unidentified[k];
+    return out;
+}
 function factIdentity(envelope) {
     const type = String(envelope?.eventType ?? '').trim();
     if (!type)
         return undefined;
-    const target = targetOf(envelope);
-    if (!target)
+    const parts = discriminatorsOf(envelope);
+    /*
+     * **정체를 못 만들면 dedupe 밖이다** — 그 사실은 다시 받을 때마다 새로 앉는다.
+     *
+     * 오늘 그것으로 저널이 부풀었다(처분·시험이 `subjectId` 를 주체로 쓰는데 그 이름이 위 목록에
+     * 없었다). 조용히 `undefined` 를 내면 다음 종류에서 또 나고 그때도 아무 흔적이 없다.
+     *
+     * 그래서 무엇이 정체를 못 만들었는지 센다(`unidentified`). 세는 것이지 막는 것이 아니다 —
+     * 정체를 못 만든다고 사실을 버리면 그것이 더 나쁘다.
+     */
+    if (!parts.length) {
+        unidentified[type] = (unidentified[type] ?? 0) + 1;
         return undefined;
+    }
     const at = timeOf(envelope);
     if (at === undefined)
         return undefined;
-    return `${type}|${target}|${at}`;
+    return `${type}|${parts.join('&')}|${at}`;
 }
 /**
  * 최근에 본 정체를 기억한다 — **크기에 상한을 둔다.**
@@ -101,6 +263,30 @@ class FactDeduper {
     }
     /** 기억하는 정체의 수 — 창. */
     static { this.WINDOW = 20_000; }
+    /**
+     * 이미 아는 것으로 **미리 기억한다** — 저널에서 읽어 채울 때.
+     *
+     * ── 왜 필요한가 (2026-09-06 측정) ─────────────────────────────────────────
+     * 이 기억은 프로세스 안에만 있다. 재기동하면 비워지고, 그 뒤 backfill 을 돌리면 **이미 저널에
+     * 있는 사실도 「처음 본 것」**이 된다.
+     *
+     * 실제로 그랬다. `mes-line-a` 를 재기동 뒤 backfill 하니 39건이 전부 다시 앉아 저널이
+     * 44 → 83건이 되고 44가지가 중복이 됐다.
+     *
+     * push 경로에서는 안 보인다. 재전송이 몇 분 안에 오므로 창 안에서 걸린다. **backfill 이 그 전제를
+     * 깬다** — 몇 달 전 사실을 지금 받으니 재기동 한 번이면 그 구간이 통째로 다시 앉는다.
+     *
+     * 그래서 backfill 이 부르기 전에 그 구간의 정체를 저널에서 읽어 여기 넣는다.
+     */
+    remember(identities) {
+        let added = 0;
+        for (const id of identities)
+            if (id && !this.seen.has(id)) {
+                this.known(id);
+                added++;
+            }
+        return added;
+    }
     /** 이 사실을 본 적이 있나 — 없으면 기억하고 `false`. */
     known(identity) {
         if (this.seen.has(identity))

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

@@ -1 +1 @@
-{"version":3,"file":"ingest-dedupe.js","sourceRoot":"","sources":["../../server/engine/ingest-dedupe.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 같은 사실을 두 번 받으면 한 번만 반영한다 — **유입 경계 한 곳에서.**\n *\n * ── 왜 필요한가 (2026-08-26) ────────────────────────────────────────────────\n * 지금 중복을 막는 것은 커넥터마다 각자 하고 있다. 그래서 커넥터가 그것을 잊으면 트윈이 그대로 두 번\n * 센다. 실제로 그랬다: 태양광 커넥터가 10초마다 물으면서 10분마다 바뀌는 값을 매번 다시 보냈고,\n * 한 주기에 76건이 되풀이됐다(커넥터에서 고쳐서 2건이 됐다).\n *\n * 그리고 이것은 웹훅으로 받을 때 더 자주 난다. 밀어 주는 방식은 재전송이 정상이다 — 그쪽이 응답을\n * 못 받으면 같은 것을 다시 보낸다.\n *\n * ── 무엇이 두 번 세어지나 ──────────────────────────────────────────────────\n * 절대값으로 말하는 사실은 여러 번 반영해도 결과가 같다(잔량 · 상태 · 적산 · 순간 kW). 그런데 세는\n * 값은 그렇지 않다.\n *\n *   구간의 표본 수 · 평균 부하(표본 수로 나눈다) · OEE 카운터 · 유입 계수\n *   그리고 지난 기록에 같은 사실이 두 줄로 남는다 — 나중에 그 기록으로 다시 계산하면 또 두 번 센다\n *\n * ── 정체를 무엇으로 보나 ────────────────────────────────────────────────────\n * 봉투의 `eventId` 로는 판단할 수 없다. 보낸 쪽이 매번 새로 만드는 순번이고(`…-energy-1` 처럼 호출마다\n * 1부터 다시 시작한다), 같은 사실을 두 번 보내면 다른 번호가 붙는다. 다른 사실에 같은 번호가 붙는 일도\n * 생긴다.\n *\n * 그래서 **사실 자체로** 판단한다.\n *\n *   무엇에 대한 것인가   설비 · 계량 지점 · 물품 · 작업 · 오더 · 자리\n *   어떤 종류인가        사건 종류(eventType)\n *   언제 잰 것인가       연결된 시스템이 준 시각\n *\n * 이 셋이 같으면 같은 사실이다. 태양광 커넥터가 `collectedAt` 으로 판단한 것과 같은 방식이고, 그것을\n * 커넥터마다 하지 않도록 여기로 올린다.\n *\n * ── 정확히 같은 것만 버린다 ─────────────────────────────────────────────────\n * 늦게 도착한 옛 사실은 버리지 않는다. 그것이 왔다는 것 자체가 사실이고, 상태에 반영되지 않는 것은\n * 커널의 순서 판단이 이미 맡는다. 여기서 버리는 것은 **정체가 완전히 같은 것**뿐이다.\n */\n\n/** 시각을 밀리초로 — 연결된 시스템이 준 시각이 먼저, 없으면 봉투의 시각. */\nfunction timeOf(envelope: any): number | undefined {\n  for (const v of [envelope?.data?.at, envelope?.data?.eventTime, envelope?.eventTime]) {\n    const t = Date.parse(String(v ?? ''))\n    if (Number.isFinite(t)) return t\n  }\n  return undefined\n}\n\n/**\n * 이 봉투가 말하는 대상 — 어휘마다 이름이 다르므로 아는 이름을 모두 본다.\n *\n * 순서가 뜻을 갖는다: 주체를 먼저 본다. 설비 사실은 「지금 붙어 있는 작업」을 함께 싣고, 작업 사실은\n * 「소속 오더」를 함께 싣는다. 아무 이름이나 먼저 보면 참조를 주체로 읽는다(승격 키에서 겪은 것과 같다).\n */\nfunction targetOf(envelope: any): string | undefined {\n  const d = envelope?.data ?? {}\n  const first = (...vals: unknown[]) => {\n    for (const v of vals) {\n      const s = String(v ?? '').trim()\n      if (s) return s\n    }\n    return undefined\n  }\n  return first(\n    d.meterId,\n    d.equipmentId,\n    d.moverId,\n    d.taskId,\n    d.orderId,\n    d.personId,\n    d.assetId,\n    d.locationId,\n    d.epcList?.[0],\n    d.parentID,\n    d.quantityList?.[0]?.epcClass,\n    d.transformationID\n  )\n}\n\n/**\n * 이 봉투가 말하는 사실의 정체 — 같으면 같은 사실이다.\n *\n * 대상이나 시각을 알 수 없으면 **정체를 만들지 않는다**(`undefined`). 그때는 거르지 않고 통과시킨다 —\n * 모르는 것을 같다고 판단하면 서로 다른 사실이 하나로 합쳐진다. 알리지 않고 잃는 것보다 두 번 세는 것이 낫다.\n */\nexport function factIdentity(envelope: any): string | undefined {\n  const type = String(envelope?.eventType ?? '').trim()\n  if (!type) return undefined\n  const target = targetOf(envelope)\n  if (!target) return undefined\n  const at = timeOf(envelope)\n  if (at === undefined) return undefined\n  return `${type}|${target}|${at}`\n}\n\n/**\n * 최근에 본 정체를 기억한다 — **크기에 상한을 둔다.**\n *\n * 전부 기억할 수는 없다(트윈 하나가 수천만 사건을 갖는다). 창을 넘으면 오래된 것부터 잊는다. 창 밖의\n * 재전송은 다시 통과하는데, 그것은 절대값 사실이라 상태에 해가 없고 지난 기록에 한 줄 더 남는다.\n * 창을 크게 잡으면 그만큼 메모리를 쓴다 — 그 값을 여기서 이름으로 못 박는다.\n *\n * **재기동을 건너지 못한다.** 프로세스가 새로 뜨면 기억이 비어 있으므로, 재기동 직후 첫 주기가 같은\n * 값을 다시 보내면 걸러지지 않는다. 그것을 막으려면 이 기억이 저장돼야 하고, 그것은 다음 걸음이다.\n * 지금은 그 사실을 여기 적어 둔다 — 적어 두지 않으면 「중복은 이제 없다」로 읽힌다.\n */\nexport class FactDeduper {\n  /** 기억하는 정체의 수 — 창. */\n  static WINDOW = 20_000\n\n  private seen = new Set<string>()\n  private order: string[] = []\n\n  /** 이 사실을 본 적이 있나 — 없으면 기억하고 `false`. */\n  private known(identity: string): boolean {\n    if (this.seen.has(identity)) return true\n    this.seen.add(identity)\n    this.order.push(identity)\n    if (this.order.length > FactDeduper.WINDOW) {\n      const gone = this.order.splice(0, this.order.length - FactDeduper.WINDOW)\n      for (const g of gone) this.seen.delete(g)\n    }\n    return false\n  }\n\n  /**\n   * 처음 보는 것만 돌려준다 — 그리고 몇 개를 버렸는지 함께 낸다.\n   *\n   * 버린 수를 함께 내는 이유: 알리지 않고 버리면 「보낸 수」와 「반영된 수」가 어긋나는데 아무도 그\n   * 이유를 모른다. 그 수가 크면 보내는 쪽이 되풀이 보내고 있다는 뜻이고, 그것은 고칠 일이다.\n   */\n  filter<T>(envelopes: readonly T[]): { fresh: T[]; duplicates: number } {\n    const fresh: T[] = []\n    let duplicates = 0\n    for (const e of envelopes) {\n      const id = factIdentity(e)\n      if (id === undefined) {\n        fresh.push(e)\n        continue\n      }\n      if (this.known(id)) duplicates++\n      else fresh.push(e)\n    }\n    return { fresh, duplicates }\n  }\n\n  /** 기억하고 있는 정체의 수 — 계기가 읽는다. */\n  size(): number {\n    return this.seen.size\n  }\n}\n"]}
+{"version":3,"file":"ingest-dedupe.js","sourceRoot":"","sources":["../../server/engine/ingest-dedupe.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 같은 사실을 두 번 받으면 한 번만 반영한다 — **유입 경계 한 곳에서.**\n *\n * ── 왜 필요한가 (2026-08-26) ────────────────────────────────────────────────\n * 지금 중복을 막는 것은 커넥터마다 각자 하고 있다. 그래서 커넥터가 그것을 잊으면 트윈이 그대로 두 번\n * 센다. 실제로 그랬다: 태양광 커넥터가 10초마다 물으면서 10분마다 바뀌는 값을 매번 다시 보냈고,\n * 한 주기에 76건이 되풀이됐다(커넥터에서 고쳐서 2건이 됐다).\n *\n * 그리고 이것은 웹훅으로 받을 때 더 자주 난다. 밀어 주는 방식은 재전송이 정상이다 — 그쪽이 응답을\n * 못 받으면 같은 것을 다시 보낸다.\n *\n * ── 무엇이 두 번 세어지나 ──────────────────────────────────────────────────\n * 절대값으로 말하는 사실은 여러 번 반영해도 결과가 같다(잔량 · 상태 · 적산 · 순간 kW). 그런데 세는\n * 값은 그렇지 않다.\n *\n *   구간의 표본 수 · 평균 부하(표본 수로 나눈다) · OEE 카운터 · 유입 계수\n *   그리고 지난 기록에 같은 사실이 두 줄로 남는다 — 나중에 그 기록으로 다시 계산하면 또 두 번 센다\n *\n * ── 정체를 무엇으로 보나 ────────────────────────────────────────────────────\n * 봉투의 `eventId` 로는 판단할 수 없다. 보낸 쪽이 매번 새로 만드는 순번이고(`…-energy-1` 처럼 호출마다\n * 1부터 다시 시작한다), 같은 사실을 두 번 보내면 다른 번호가 붙는다. 다른 사실에 같은 번호가 붙는 일도\n * 생긴다.\n *\n * 그래서 **사실 자체로** 판단한다.\n *\n *   무엇에 대한 것인가   설비 · 계량 지점 · 물품 · 작업 · 오더 · 자리\n *   어떤 종류인가        사건 종류(eventType)\n *   언제 잰 것인가       연결된 시스템이 준 시각\n *\n * 이 셋이 같으면 같은 사실이다. 태양광 커넥터가 `collectedAt` 으로 판단한 것과 같은 방식이고, 그것을\n * 커넥터마다 하지 않도록 여기로 올린다.\n *\n * ── 정확히 같은 것만 버린다 ─────────────────────────────────────────────────\n * 늦게 도착한 옛 사실은 버리지 않는다. 그것이 왔다는 것 자체가 사실이고, 상태에 반영되지 않는 것은\n * 커널의 순서 판단이 이미 맡는다. 여기서 버리는 것은 **정체가 완전히 같은 것**뿐이다.\n */\n\n/** 시각을 밀리초로 — 연결된 시스템이 준 시각이 먼저, 없으면 봉투의 시각. */\nfunction timeOf(envelope: any): number | undefined {\n  for (const v of [envelope?.data?.at, envelope?.data?.eventTime, envelope?.eventTime]) {\n    const t = Date.parse(String(v ?? ''))\n    if (Number.isFinite(t)) return t\n  }\n  return undefined\n}\n\n/**\n * 이 봉투가 말하는 것을 **가르는 값들** — 하나라도 다르면 다른 사실이다.\n *\n * ── 예전에는 하나만 골랐다 (2026-09-05 실측) ───────────────────────────────\n * 아는 이름을 순서대로 보고 **먼저 걸리는 하나**를 대상으로 삼았다. 「주체를 먼저 본다」는 판단\n * 자체는 옳다 — 설비 사실은 「지금 붙어 있는 작업」을 참조로 싣는다. 그런데 **고르고 나머지를\n * 버린 것**이 결함이었다.\n *\n * 실제로 난 일: plant 이 실적 둘을 보냈는데 한 건이 저널에 안 남았다.\n *\n *   seq 36   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-01 · goodCount 12\n *   seq 41   quality.output   moverId EQ-CT-MWELD-01 · taskId PR-CT-WIRE-02 · goodCount  9\n *\n * 두 실적의 시각이 같았고(원본이 끝시각을 복사) `moverId` 가 `taskId` 보다 먼저라 **둘이 한 사실이\n * 됐다.** 거부가 아니라 되풀이로 세어졌다 — `offered 5 · rejected 0 · journaled 3`.\n *\n * **구별할 값이 이미 봉투 안에 있었는데 판정이 그것을 안 봤다.**\n *\n * ── 그리고 EPCIS 도 같았다 ─────────────────────────────────────────────────\n * 저널 246만 건에 현재 규칙을 다시 걸어 보니 겹치는 묶음이 여섯이었고, 전부 이 모양이다.\n *\n *   같은 EPC · 같은 밀리초\n *     ① bizStep receiving      action ADD      disposition sellable_accessible\n *     ② bizStep commissioning  action OBSERVE  disposition reserved\n *\n * **한 개체의 서로 다른 관측**이다. EPCIS 에서 이상한 일이 아닌데 규칙이 그 셋을 안 봤다.\n *\n * ── 왜 넓히는 쪽이 맞나 ────────────────────────────────────────────────────\n * 이 파일이 스스로 적어 둔 값이 그것이다 — 「알리지 않고 잃는 것보다 두 번 세는 것이 낫다」.\n * 지금 거동은 **알리지 않고 잃는 쪽**이었다.\n *\n * 넓혀도 되풀이는 그대로 걸린다: 같은 봉투를 다시 보내면 **이 값들이 전부 같다.** 넓히는 것은\n * 「다른 사실을 합치지 않는다」만 강해지고 「되풀이를 잡는다」는 안 약해진다.\n */\nfunction discriminatorsOf(envelope: any): string[] {\n  const d = envelope?.data ?? {}\n  const out: string[] = []\n  const put = (name: string, v: unknown) => {\n    const t = String(v ?? '').trim()\n    if (t) out.push(`${name}=${t}`)\n  }\n\n  /*\n   * 주체·참조를 **다 적는다.** 순서는 값이 아니라 이름으로 고정되므로 봉투마다 흔들리지 않는다.\n   *\n   * ⚠ **이 목록은 계약의 `identity` 선언을 손으로 옮긴 것이다.** 계약이 kind 마다 무엇이 그 사실을\n   * 가리키는지 이미 선언하는데(`operational-ingest.ts` 의 `SPECS[kind].identity`), 그것을 내보내지\n   * 않아서 여기가 따로 들고 있다.\n   *\n   * 그래서 새 kind 가 생기면 여기가 조용히 뒤처진다. 실제로 두 번 그랬다 — `subjectId`(처분)와\n   * `testableObjectId`(시험)가 빠져 있었고, 그동안 그 두 종류는 정체를 못 만들거나 서로 다른 사실이\n   * 뭉칠 수 있었다.\n   *\n   * 계약이 `operationalIdentityField(kind)` 를 내보내면 이 목록을 지운다. 그 문을 열어 두었고\n   * 배포를 기다린다.\n   */\n  put('meter', d.meterId)\n  put('equipment', d.equipmentId)\n  put('mover', d.moverId) // vocabulary-guard: allow — 봉투의 옛 세대 필드 이름(저장된 계약)\n  put('task', d.taskId)\n  put('order', d.orderId)\n  put('person', d.personId)\n  put('asset', d.assetId)\n  put('location', d.locationId) // vocabulary-guard: allow — 같음\n  put('epc', d.epcList?.[0])\n  put('parent', d.parentID)\n  put('class', d.quantityList?.[0]?.epcClass)\n  put('transformation', d.transformationID)\n  /*\n   * ── 주체가 `subjectId` 인 사실이 있다 (2026-09-06 측정) ──────────────────────\n   * 부적합 처분과 시험 결과는 **표준 `TestableObjectID` 와 같은 자리**를 쓴다(로트 · 설비 · 자리에\n   * 두루 쓰는 하나의 이름). 그 이름이 여기 없어서 두 종류가 **정체를 못 만들었다** —\n   * `parts` 가 비면 `factIdentity` 가 `undefined` 를 내고, 그러면 dedupe 밖이다.\n   *\n   * 실제로 그랬다. `fillTwinScope` 를 두 번 돌릴 때마다 그 둘이 7건씩 다시 앉았다(처분 4 · 시험 3).\n   * 나머지 34건은 걸러졌는데 이 둘만 계속 늘었다.\n   */\n  put('subject', d.subjectId)\n  put('spec', d.specId)\n  /*\n   * 시험 결과의 주체는 `testableObjectId` 다 — 표준 `TestableObjectID` 의 이름을 그대로 쓴다.\n   *\n   * 이 이름이 없어서 **같은 명세로 같은 시각에 잰 서로 다른 로트가 한 사실로 뭉쳤다.** 중복이 생기는\n   * 것보다 나쁘다 — 두 로트의 시험 결과 중 하나가 사라진다.\n   *\n   * 실제로 `mes-miratek` 에 같은 시험 결과가 10건 있었다(2026-09-06 확인). 그것은 뭉친 것이 아니라\n   * 반대로 dedupe 를 못 지난 것인데, 같은 자리에서 뭉치는 쪽도 열려 있었다.\n   */\n  put('object', d.testableObjectId)\n  /* 완료 선언의 주체 — 「이 축은 여기까지가 전부다」를 말하는 축 이름. */\n  put('axis', d.completeAxis)\n\n  /*\n   * EPCIS 는 「무엇을 말하는 관측인가」가 이 셋으로 갈린다. 한 개체가 한 순간에 두 관측을 갖는\n   * 것은 표준에서 정상이고, 이것을 안 보면 뒤엣것이 사라진다.\n   */\n  put('bizStep', d.bizStep)\n  put('action', d.action)\n  put('disposition', d.disposition)\n\n  /*\n   * ── 변환은 **무엇이 무엇으로 되었나**로 갈린다 (2026-09-07 측정) ─────────────\n   * 이 자리가 없어서 **사실 하나가 없어졌습니다.** 거절이 아니라 되풀이로 세어져서 경고도 없었습니다.\n   *\n   * ```\n   * plant outbox seq 37   in LOT-CT-SIDE-001 24개  →  out LOT-CT-MAIN-003 12개\n   * plant outbox seq 42   in LOT-CT-SIDE-001 18개  →  out LOT-CT-MAIN-004  9개\n   *                       transformationID · bizStep · 초까지 전부 같다\n   * 저널에 남은 것        LOT-CT-MAIN-003 하나\n   * ```\n   *\n   * `LOT-CT-MAIN-004` 를 어느 패널로 만들었는지 트윈이 답하지 못하는 상태였습니다.\n   *\n   * 그리고 **구별할 값이 봉투 안에 이미 있었습니다** — `outputQuantityList[0].epcClass` 가 서로\n   * 다릅니다. 이 파일 머리말이 적어 둔 그 모양 그대로입니다: 판정이 그것을 안 봤습니다.\n   *\n   * 산출만 보지 않고 **입력도 봅니다.** 같은 로트를 같은 초에 두 번 소비하면서 산출 이름이 같은\n   * 경우(수량만 다른 분할)가 남고, 그때 입력 수량이 유일한 차이입니다. 수량까지 넣는 이유가 그것입니다.\n   */\n  put('inClass', classOf(d.inputQuantityList))\n  put('inEpc', d.inputEPCList?.[0])\n  put('inQty', qtyOf(d.inputQuantityList))\n  put('outClass', classOf(d.outputQuantityList))\n  put('outEpc', d.outputEPCList?.[0])\n  put('outQty', qtyOf(d.outputQuantityList))\n  /*\n   * 담김의 자식도 같은 이유로 본다 — 한 팔레트에 서로 다른 묶음을 같은 초에 두 번 실으면 뒤엣것이\n   * 사라진다. 위 변환에서 실제로 그렇게 잃었으니 여기도 함께 막는다(한 종류만 고치면 나머지에 남는다).\n   */\n  put('childEpc', d.childEPCs?.[0])\n  put('childClass', classOf(d.childQuantityList))\n  put('childQty', qtyOf(d.childQuantityList))\n  /*\n   * 어느 오더의 사실인가도 정체의 일부다. 같은 공정을 같은 초에 두 오더로 돌리는 것은 정상이고,\n   * 이것을 안 보면 뒤엣것이 사라진다.\n   */\n  put('tx', d.bizTransactionList?.[0]?.bizTransaction)\n\n  return out\n}\n\n/** 수량 목록의 첫 종류 — 목록이 비면 `undefined`(빈 문자열을 넣지 않는다). */\nfunction classOf(list: unknown): string | undefined {\n  const first = Array.isArray(list) ? (list[0] as any) : undefined\n  const v = first?.epcClass\n  return typeof v === 'string' && v.trim() ? v : undefined\n}\n\n/**\n * 수량 목록을 수까지 적는다 — 종류가 같고 수량만 다른 사실을 가른다.\n *\n * 목록 전체를 적는다. 첫 원소만 보면 「같은 것 둘 + 다른 것 하나」가 첫 원소로는 구별되지 않는다.\n */\nfunction qtyOf(list: unknown): string | undefined {\n  if (!Array.isArray(list) || !list.length) return undefined\n  const parts = list.map((x: any) => `${x?.epcClass ?? ''}:${x?.quantity ?? ''}${x?.uom ? '/' + x.uom : ''}`)\n  return parts.join('|')\n}\n\n/**\n * 이 봉투가 말하는 사실의 정체 — 같으면 같은 사실이다.\n *\n * 대상이나 시각을 알 수 없으면 **정체를 만들지 않는다**(`undefined`). 그때는 거르지 않고 통과시킨다 —\n * 모르는 것을 같다고 판단하면 서로 다른 사실이 하나로 합쳐진다. 알리지 않고 잃는 것보다 두 번 세는 것이 낫다.\n */\n/**\n * 정체를 못 만든 사실을 **종류별로** 센다 — dedupe 밖으로 나간 것들.\n *\n * 이 수가 0이 아니면 그 종류는 다시 받을 때마다 저널에 다시 앉는다. 그 종류의 주체 이름을\n * `discriminatorsOf` 에 더해야 한다.\n */\nconst unidentified: Record<string, number> = {}\n\n/** 지금까지 정체를 못 만든 것 — 종류별. 읽고 비운다. */\nexport function takeUnidentified(): Record<string, number> {\n  const out = { ...unidentified }\n  for (const k of Object.keys(unidentified)) delete unidentified[k]\n  return out\n}\n\nexport function factIdentity(envelope: any): string | undefined {\n  const type = String(envelope?.eventType ?? '').trim()\n  if (!type) return undefined\n  const parts = discriminatorsOf(envelope)\n  /*\n   * **정체를 못 만들면 dedupe 밖이다** — 그 사실은 다시 받을 때마다 새로 앉는다.\n   *\n   * 오늘 그것으로 저널이 부풀었다(처분·시험이 `subjectId` 를 주체로 쓰는데 그 이름이 위 목록에\n   * 없었다). 조용히 `undefined` 를 내면 다음 종류에서 또 나고 그때도 아무 흔적이 없다.\n   *\n   * 그래서 무엇이 정체를 못 만들었는지 센다(`unidentified`). 세는 것이지 막는 것이 아니다 —\n   * 정체를 못 만든다고 사실을 버리면 그것이 더 나쁘다.\n   */\n  if (!parts.length) {\n    unidentified[type] = (unidentified[type] ?? 0) + 1\n    return undefined\n  }\n  const at = timeOf(envelope)\n  if (at === undefined) return undefined\n  return `${type}|${parts.join('&')}|${at}`\n}\n\n/**\n * 최근에 본 정체를 기억한다 — **크기에 상한을 둔다.**\n *\n * 전부 기억할 수는 없다(트윈 하나가 수천만 사건을 갖는다). 창을 넘으면 오래된 것부터 잊는다. 창 밖의\n * 재전송은 다시 통과하는데, 그것은 절대값 사실이라 상태에 해가 없고 지난 기록에 한 줄 더 남는다.\n * 창을 크게 잡으면 그만큼 메모리를 쓴다 — 그 값을 여기서 이름으로 못 박는다.\n *\n * **재기동을 건너지 못한다.** 프로세스가 새로 뜨면 기억이 비어 있으므로, 재기동 직후 첫 주기가 같은\n * 값을 다시 보내면 걸러지지 않는다. 그것을 막으려면 이 기억이 저장돼야 하고, 그것은 다음 걸음이다.\n * 지금은 그 사실을 여기 적어 둔다 — 적어 두지 않으면 「중복은 이제 없다」로 읽힌다.\n */\nexport class FactDeduper {\n  /** 기억하는 정체의 수 — 창. */\n  static WINDOW = 20_000\n\n  private seen = new Set<string>()\n  private order: string[] = []\n\n  /**\n   * 이미 아는 것으로 **미리 기억한다** — 저널에서 읽어 채울 때.\n   *\n   * ── 왜 필요한가 (2026-09-06 측정) ─────────────────────────────────────────\n   * 이 기억은 프로세스 안에만 있다. 재기동하면 비워지고, 그 뒤 backfill 을 돌리면 **이미 저널에\n   * 있는 사실도 「처음 본 것」**이 된다.\n   *\n   * 실제로 그랬다. `mes-line-a` 를 재기동 뒤 backfill 하니 39건이 전부 다시 앉아 저널이\n   * 44 → 83건이 되고 44가지가 중복이 됐다.\n   *\n   * push 경로에서는 안 보인다. 재전송이 몇 분 안에 오므로 창 안에서 걸린다. **backfill 이 그 전제를\n   * 깬다** — 몇 달 전 사실을 지금 받으니 재기동 한 번이면 그 구간이 통째로 다시 앉는다.\n   *\n   * 그래서 backfill 이 부르기 전에 그 구간의 정체를 저널에서 읽어 여기 넣는다.\n   */\n  remember(identities: readonly string[]): number {\n    let added = 0\n    for (const id of identities) if (id && !this.seen.has(id)) { this.known(id); added++ }\n    return added\n  }\n\n  /** 이 사실을 본 적이 있나 — 없으면 기억하고 `false`. */\n  private known(identity: string): boolean {\n    if (this.seen.has(identity)) return true\n    this.seen.add(identity)\n    this.order.push(identity)\n    if (this.order.length > FactDeduper.WINDOW) {\n      const gone = this.order.splice(0, this.order.length - FactDeduper.WINDOW)\n      for (const g of gone) this.seen.delete(g)\n    }\n    return false\n  }\n\n  /**\n   * 처음 보는 것만 돌려준다 — 그리고 몇 개를 버렸는지 함께 낸다.\n   *\n   * 버린 수를 함께 내는 이유: 알리지 않고 버리면 「보낸 수」와 「반영된 수」가 어긋나는데 아무도 그\n   * 이유를 모른다. 그 수가 크면 보내는 쪽이 되풀이 보내고 있다는 뜻이고, 그것은 고칠 일이다.\n   */\n  filter<T>(envelopes: readonly T[]): { fresh: T[]; duplicates: number } {\n    const fresh: T[] = []\n    let duplicates = 0\n    for (const e of envelopes) {\n      const id = factIdentity(e)\n      if (id === undefined) {\n        fresh.push(e)\n        continue\n      }\n      if (this.known(id)) duplicates++\n      else fresh.push(e)\n    }\n    return { fresh, duplicates }\n  }\n\n  /** 기억하고 있는 정체의 수 — 계기가 읽는다. */\n  size(): number {\n    return this.seen.size\n  }\n}\n"]}

package/dist-server/engine/ingest-health.d.ts

@@ -34,6 +34,8 @@ export interface IngestWindow {
      * 세면 그 개선도, 되돌아가는 것도 보이지 않는다.
      */
     flushes: number;
+    /** 이 창에서 저널에 안 간 어휘 요소의 수 — 사라진 것이 아니라 저널로 가지 않는 것이다. */
+    vocabulary: number;
 }
 /** 거부 표본 하나 — 매핑을 고치려면 실제 모양을 봐야 한다. */
 export interface RejectSample {
@@ -54,6 +56,17 @@ export interface IngestLedger {
     /** 누적 제시·거부·미전달. */
     offered: number;
     rejected: number;
+    /**
+     * **저널에 안 가는 어휘 요소의 수** — 로트 번호·소비기한처럼 시각축이 없는 값.
+     *
+     * ── 왜 세나 (2026-09-05, 인티그레이션 레인이 셈으로 찾음) ─────────────────
+     * 어휘는 일부러 저널로 안 간다(§`canonical-ingest`) — 그것이 옳다. 그런데 **그 수를 빼 주는
+     * 자리가 없어서** 「보낸 것 − 앉은 것」이 안 맞고, 그 차이를 「사라졌다」로 읽게 된다.
+     *
+     * 실제로 그랬다: 커서 20 · 저널 17 · 어휘 1 → 사람이 손으로 세서 「둘이 빈다」를 찾았다. 그
+     * 뺄셈을 코드가 하려면 이 항이 있어야 한다.
+     */
+    vocabulary: number;
     undelivered: number;
     /** 누적 — 적힌 행과 두드린 횟수. */
     rows: number;
@@ -265,6 +278,16 @@ export declare function recordCursorStall(ledger: IngestLedger, reason: string,
  */
 export declare function recordIngestSource(ledger: IngestLedger, source: string, count: number, nowMs: number): void;
 /** 같은 사실이 두 번 와서 버린 수 — 알리지 않고 버리지 않는다. */
+/**
+ * **저널에 안 간 어휘 요소를 센다** — 없어진 것이 아니라 저널로 가지 않는 것이다.
+ *
+ * 어휘(로트 번호·소비기한 등)는 시각축이 없어 일부러 저널로 안 간다. 그런데 그 수를 빼 주는 자리가
+ * 없으면 「보낸 것 − 앉은 것」이 안 맞고, 그 차이를 **사라진 것으로 읽게 된다.**
+ *
+ * 창을 굴리지 않는다 — 부르는 쪽(`recordIngest`)이 이미 굴린 뒤에 부른다. 여기서 또 굴리면 한
+ * 유입이 두 창에 걸친다.
+ */
+export declare function recordVocabulary(ledger: IngestLedger, count: number): void;
 export declare function recordDuplicates(ledger: IngestLedger, count: number, nowMs: number): void;
 export declare function recordWithheld(ledger: IngestLedger, reason: string, count: number, nowMs: number): void;
 /** 창을 넘겼으면 지운다 — 풀린 정체가 화면에 남아 있으면 그것도 거짓이다. */
@@ -371,7 +394,22 @@ export type SyncVerdict = 'syncing' /** 유입이 있고 통과율이 문턱 이
  * 그래서 **화면 문구는 관측 그대로** 적는다(「트윈에 닿지 않고 버려지는 중」). 이 키 이름은 서버·화면·
  * 시험에 걸친 계약 문자열이라 그대로 두지만, 이름을 원인으로 읽지 않는다.
  */
- | 'twin-not-running' | 'no-traffic' /** 피드는 붙었는데 제시가 0 — 원천·망을 본다 */ | 'not-connected' /** 피드 자체가 없다 — 결선한다 */ | 'not-applicable' /** 원본이 먹이지 않는 트윈(시뮬)·멈춘 트윈 — 물을 대상이 아니다 */ | 'unknown'; /** 한 번도 받지 않았거나 창이 아직 닫히지 않았다 — 기다린다 */
+ | 'twin-not-running' | 'no-traffic' /** 피드는 붙었는데 제시가 0 — 원천·망을 본다 */ | 'not-connected' /** 피드 자체가 없다 — 결선한다 */ | 'not-applicable' /** 원본이 먹이지 않는 트윈(시뮬)·멈춘 트윈 — 물을 대상이 아니다 */
+/**
+ * **지금은 조용한 것이 정상이다** — 원천이 지금 시각에 내놓지 않는다.
+ *
+ * ── 왜 초록도 빨강도 아닌가 (2026-09-04) ─────────────────────────────────
+ * 태양광은 밤에 발전하지 않고, 업무시간만 도는 원천은 저녁에 아무것도 내지 않는다. 그 침묵을
+ * `no-traffic` 으로 부르면 **정상인 밤마다 절반이 빨갛게 난다.** 거짓 빨강이 쌓이면 진짜 빨강도
+ * 같이 안 읽힌다 — 오늘 UX 레인이 「늘 참인 경고는 벽지가 된다」고 한 것과 같은 부류다.
+ *
+ * 그렇다고 `syncing` 도 아니다. 지금 받고 있는 것이 아니고, 초록으로 칠하면 **밤에 정말 끊긴
+ * 원천**을 아침까지 아무도 모른다.
+ *
+ * 그래서 셋째 값이다: 「지금은 안 오는 것이 맞다」. 화면은 이것을 회색으로 그리고, 다음에 올
+ * 시각을 함께 말할 수 있다.
+ */
+ | 'expected-quiet' | 'unknown'; /** 한 번도 받지 않았거나 창이 아직 닫히지 않았다 — 기다린다 */
 export declare function syncVerdictOf(args: {
     /** `live-feed-registry.liveFeedStateOf` 의 답을 그대로 받는다 — 판정 어휘를 두 벌 만들지 않는다. */
     feedState: 'attached' | 'detached' | 'not-applicable';
@@ -386,6 +424,27 @@ export declare function syncVerdictOf(args: {
     nowMs?: number;
     /** 마지막으로 **버려진** 시각. 한 번도 없으면 `-1`. */
     lastUndeliveredAtMs?: number;
+    /**
+     * **이 원천은 이만큼 조용해도 정상이다** — 긷는 주기를 원천 쪽이 선언한 값.
+     *
+     * 없으면 창 하나(`STALE_AFTER_MS`)로 견준다(지금까지의 거동). 15분마다 긷는 원천은 그 값을
+     * 선언해야 하고, 안 하면 긷는 사이마다 「유입 없음」으로 보인다 — 이 파일이 아래에서 그 한계를
+     * 스스로 적어 두고 있었다.
+     *
+     * 장부는 원천의 주기를 알 수 없다. **선언만이 그것을 아는 유일한 길이다.**
+     */
+    expectedSilenceMs?: number;
+    /**
+     * **지금이 그 원천의 조용한 시간인가** — 근무 달력 판정의 결과만 받는다.
+     *
+     * 달력 자체를 여기서 보지 않는다: 이 함수는 순수하고, 달력·시간대·시각 해석은 계약이 이미
+     * 한 자리에서 한다(`inWorkCalendar`·`offCalendarAt`). 부르는 쪽이 그것을 불러 참·거짓만 준다 —
+     * `capabilityOf` 가 `requiredTests` 를 받는 것과 같은 규율이다.
+     *
+     * **모르면 주지 않는다.** `false` 로 채우면 「지금은 활동 시간이다」를 단언하는 것이 되고, 달력을
+     * 선언하지 않은 원천이 전부 그렇게 읽힌다.
+     */
+    quietNow?: boolean;
     /**
      * 지금까지 제시된 누적 수 — **「받고 있는 중」과 「오는 것이 없다」를 가르는 사실**이다.
      *

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

@@ -34,6 +34,7 @@ exports.recordRecovered = recordRecovered;
 exports.clearReadFailure = clearReadFailure;
 exports.recordCursorStall = recordCursorStall;
 exports.recordIngestSource = recordIngestSource;
+exports.recordVocabulary = recordVocabulary;
 exports.recordDuplicates = recordDuplicates;
 exports.recordWithheld = recordWithheld;
 exports.clearCursorStall = clearCursorStall;
@@ -134,6 +135,21 @@ function recordIngestSource(ledger, source, count, nowMs) {
     cur.lastAtMs = nowMs;
 }
 /** 같은 사실이 두 번 와서 버린 수 — 알리지 않고 버리지 않는다. */
+/**
+ * **저널에 안 간 어휘 요소를 센다** — 없어진 것이 아니라 저널로 가지 않는 것이다.
+ *
+ * 어휘(로트 번호·소비기한 등)는 시각축이 없어 일부러 저널로 안 간다. 그런데 그 수를 빼 주는 자리가
+ * 없으면 「보낸 것 − 앉은 것」이 안 맞고, 그 차이를 **사라진 것으로 읽게 된다.**
+ *
+ * 창을 굴리지 않는다 — 부르는 쪽(`recordIngest`)이 이미 굴린 뒤에 부른다. 여기서 또 굴리면 한
+ * 유입이 두 창에 걸친다.
+ */
+function recordVocabulary(ledger, count) {
+    if (!Number.isFinite(count) || count <= 0)
+        return;
+    ledger.vocabulary += count;
+    ledger.window.vocabulary += count;
+}
 function recordDuplicates(ledger, count, nowMs) {
     if (count <= 0)
         return;
@@ -201,7 +217,7 @@ exports.RECORD_MAX = 2000;
 exports.HEALTHY_ACCEPTED_RATIO = 0.95;
 function newIngestLedger() {
     return {
-        window: { startMs: -1, endMs: -1, offered: 0, rejected: 0, undelivered: 0, rows: 0, flushes: 0 },
+        window: { startMs: -1, endMs: -1, offered: 0, rejected: 0, vocabulary: 0, undelivered: 0, rows: 0, flushes: 0 },
         trend: [],
         trendDropped: 0,
         offered: 0,
@@ -213,6 +229,7 @@ function newIngestLedger() {
         lastUndeliveredAtMs: -1,
         bySource: {},
         duplicates: 0,
+        vocabulary: 0,
         lastDuplicateAtMs: -1,
         byReason: {},
         reasonsCapped: false,
@@ -244,7 +261,7 @@ function rollIngestWindow(ledger, nowMs, windowMs = exports.INGEST_WINDOW_MS, on
         return;
     const closed = { ...ledger.window, endMs: nowMs };
     ledger.trend.push(closed);
-    ledger.window = { startMs: nowMs, endMs: -1, offered: 0, rejected: 0, undelivered: 0, rows: 0, flushes: 0 };
+    ledger.window = { startMs: nowMs, endMs: -1, offered: 0, rejected: 0, vocabulary: 0, undelivered: 0, rows: 0, flushes: 0 };
     if (ledger.trend.length > exports.TREND_LIMIT) {
         const drop = ledger.trend.length - exports.TREND_LIMIT;
         ledger.trend.splice(0, drop);
@@ -397,11 +414,27 @@ function syncVerdictOf(args) {
      * 한계 — 한 창(10분)보다 **느리게 긷는 원천**은 긷는 사이에 「유입 없음」으로 보인다. 장부는 원천의
      * 주기를 모르므로 이보다 정확히 답할 수 없다. 주기를 알게 되면 그 값으로 견주는 것이 맞다.
      */
+    /*
+     * 견줄 길이는 **원천이 선언한 값이 있으면 그것**이다(§`expectedSilenceMs`). 없으면 창 하나 —
+     * 위 한계 문단이 말하는 그대로다.
+     */
+    const silenceLimitMs = typeof args.expectedSilenceMs === 'number' && args.expectedSilenceMs > 0
+        ? args.expectedSilenceMs
+        : exports.STALE_AFTER_MS;
     if (typeof args.lastAtMs === 'number' && typeof args.nowMs === 'number') {
-        if (args.lastAtMs < 0)
-            return 'unknown'; /* 붙었지만 한 번도 받지 않았다 — 기다린다 */
-        if (args.nowMs - args.lastAtMs > exports.STALE_AFTER_MS)
-            return 'no-traffic';
+        if (args.lastAtMs < 0) {
+            /* 한 번도 받지 않았는데 지금이 조용한 시간이면 「기다린다」가 아니라 「지금은 맞다」다. */
+            return args.quietNow === true ? 'expected-quiet' : 'unknown';
+        }
+        if (args.nowMs - args.lastAtMs > silenceLimitMs) {
+            /*
+             * 오래 조용하다. **지금이 그 원천의 조용한 시간이면 그것이 정상이다.**
+             *
+             * 이 갈래를 위쪽(버려지는 중·피드 없음)보다 뒤에 두는 이유: 사실이 사라지고 있거나 결선이
+             * 없는 것은 **몇 시든 문제**다. 밤이라고 덮으면 밤새 새는 것을 아침에 안다.
+             */
+            return args.quietNow === true ? 'expected-quiet' : 'no-traffic';
+        }
     }
     /*
      * ── **닿았는데 오는 것이 없다** 를 「모른다」로 답하지 않는다 (2026-08-28) ────
@@ -424,10 +457,12 @@ function syncVerdictOf(args) {
     if (!args.recent) {
         const touched = typeof args.lastAtMs === 'number' && args.lastAtMs >= 0;
         const nothingOffered = (args.offeredTotal ?? 0) <= 0;
-        return touched && nothingOffered ? 'no-traffic' : 'unknown';
+        if (touched && nothingOffered)
+            return args.quietNow === true ? 'expected-quiet' : 'no-traffic';
+        return 'unknown';
     }
     if (args.recent.offered <= 0)
-        return 'no-traffic';
+        return args.quietNow === true ? 'expected-quiet' : 'no-traffic';
     const ratio = (args.recent.offered - args.recent.rejected) / args.recent.offered;
     return ratio >= (args.threshold ?? exports.HEALTHY_ACCEPTED_RATIO) ? 'syncing' : 'mapping-blocked';
 }