@things-factory/headless-twin 10.0.12 → 10.0.13

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

@@ -0,0 +1,434 @@
+"use strict";
+/*
+ * 동기화 건강 — **이 트윈이 현장과 맞춰지고 있나.** 순수(import 없음).
+ *
+ * ── 한 질문 ─────────────────────────────────────────────────────────────────
+ * 화면에서 값이 변하지 않을 때 원인이 넷인데, 지금까지 **넷이 똑같이 보였다.**
+ *   ① 피드가 붙지 않았다  ② 붙었는데 아무것도 오지 않는다
+ *   ③ 오는데 전부 거부된다  ④ 정상인데 현장이 조용하다
+ * ③은 특히 나쁘다 — 커넥터의 매핑이 한 글자 틀리면 트윈은 「빈 공장」이 되고, 그 사실이 서버 로그
+ * 한 줄에만 남았다. 현장에 나간 사람은 로그를 뒤져야 했다.
+ *
+ * ── 왜 저널로는 답할 수 없나 ────────────────────────────────────────────────
+ * **거부된 것은 저널에 없다** — 거부의 뜻이 그것이다. 저널을 접으면 통과한 쪽만 나온다. 거부의 추이는
+ * 세는 자리를 따로 두어야 나온다. 이 장부가 그 자리다.
+ *
+ * ── 왜 건마다 저장하지 않나 ─────────────────────────────────────────────────
+ * 라이브 계측은 초당 여러 건이다. 거부마다 행을 쓰면 그 자체가 부하가 된다(`reference-live.ts` 가
+ * 이미 그렇게 적어 두었다). 그리고 이 패키지는 **`integration-base` 를 알지 않는다**(이식성 규약) —
+ * 시나리오 경로가 쓰는 dead-letter 를 여기서 부를 수 없다. 그래서 **집계한다.**
+ *
+ * ── 통과와 거부를 함께 센다 ─────────────────────────────────────────────────
+ * 거부만 그리면 「유입 없음」과 「정상」이 **둘 다 거부 0** 으로 같아 보인다. 제시 수가 있어야 갈린다.
+ *
+ * ── 지키는 규율 넷 ──────────────────────────────────────────────────────────
+ *  ① **닫힌 창만 「최근」이다** — 채우는 중인 창은 과소 집계다(부하 계기판에서 겪었다).
+ *  ② **0 과 「없음」을 가른다** — 안 받은 것은 `null`, 받았지만 거부 0 은 `0`.
+ *  ③ **조용히 자르지 않는다** — 표본·추이 상한에서 밀려난 수를 함께 낸다.
+ *  ④ **통과율에 1 을 함부로 쓰지 않는다** — 1,000건 중 1건 거부는 0.999 다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HEALTHY_ACCEPTED_RATIO = exports.RECORD_MAX = exports.SAMPLE_LIMIT = exports.OTHER_REASON = exports.REASON_LIMIT = exports.TREND_LIMIT = exports.STALE_AFTER_MS = exports.INGEST_WINDOW_MS = void 0;
+exports.recordReadFailure = recordReadFailure;
+exports.clearReadFailure = clearReadFailure;
+exports.newIngestLedger = newIngestLedger;
+exports.rollIngestWindow = rollIngestWindow;
+exports.reasonKey = reasonKey;
+exports.recordIngest = recordIngest;
+exports.recordJournalWrite = recordJournalWrite;
+exports.syncVerdictOf = syncVerdictOf;
+exports.ingestHealth = ingestHealth;
+/**
+ * 읽기 실패를 장부에 적는다 — **받은 것이 없는 것과 가른다.**
+ *
+ * 연속 실패의 시작 시각을 지키는 것이 이 함수의 요점이다: 매번 새로 적으면 「20분째 못 읽는다」를
+ * 말할 수 없고, 화면은 늘 「방금 실패했다」만 보게 된다.
+ */
+function recordReadFailure(ledger, reason, nowMs, stream) {
+    const prev = ledger.readFailure;
+    ledger.readFailure = {
+        consecutive: (prev?.consecutive ?? 0) + 1,
+        sinceMs: prev?.sinceMs ?? nowMs,
+        lastAtMs: nowMs,
+        reason,
+        ...(stream ? { stream } : {})
+    };
+}
+/**
+ * 읽기가 성공했다 — 단절 기록을 지운다.
+ *
+ * **빈 읽기도 성공이다**: 원본이 「새 것이 없다」고 답한 것은 닿았다는 뜻이다. 그 둘을 같게 두면
+ * 조용한 원본이 끊긴 원본으로 보인다(고치려던 것의 반대 방향으로 틀린다).
+ */
+function clearReadFailure(ledger) {
+    if (ledger.readFailure)
+        delete ledger.readFailure;
+}
+/** 창 길이 — 10분. 부하 계기판(10초)과 다른 값이라 이름을 따로 둔다(같은 이름이면 섞인다). */
+exports.INGEST_WINDOW_MS = 600_000;
+/**
+ * 이만큼 아무것도 오지 않으면 「유입 없음」이라 말한다.
+ *
+ * 창 하나와 같게 둔다 — 한 창을 통째로 비운 것은 실제로 「그 구간에 아무것도 오지 않았다」이고, 추이의
+ * 그 자리도 비게 된다. 그림과 알약이 같은 말을 하게 하려면 같은 길이여야 한다.
+ */
+exports.STALE_AFTER_MS = exports.INGEST_WINDOW_MS;
+/** 추이 보관 창 수 — 36창 × 10분 = 6시간. 「고친 것이 먹혔나」를 보기에 충분하고 메모리는 숫자 넷×36 이다. */
+exports.TREND_LIMIT = 36;
+/**
+ * 사유 종류 상한.
+ *
+ * **없으면 메모리가 끝없이 자란다.** 사유 문구에 레코드마다 다른 값이 섞이는 커넥터가 하나만 있어도
+ * (`unknown bizStep "PUTAWAY_X17"`, `…X18`, …) 키가 무한히 늘어난다. 초당 1만 건 규모에서 이것은
+ * 미미한 오버헤드가 아니라 누수다.
+ *
+ * 넘치면 `OTHER_REASON` 한 칸에 모으고 **몇 종을 접었는지 함께 낸다**(조용히 자르지 않는다).
+ * 30종이면 고칠 곳을 찾기에 충분하다 — 목록을 훑는 일이 아니라 매핑 몇 줄을 고치는 일이다.
+ */
+exports.REASON_LIMIT = 30;
+/** 상한을 넘긴 사유들이 모이는 칸. */
+exports.OTHER_REASON = '(other reasons)';
+/**
+ * 표본 상한 — **사유마다 한 건**만 든다.
+ *
+ * 같은 사유 20건보다 **서로 다른 사유 1건씩**이 매핑을 고치는 데 유용하다. 그리고 이 규칙이 성능을
+ * 지킨다: 그 사유의 표본이 이미 있으면 `JSON.stringify` 를 **아예 하지 않는다.** 실측(레코드 241바이트)
+ * 으로 건당 0.24µs 인데, 초당 1만 건이 전부 거부되면 9,980건은 만들자마자 버려지는 문자열이었다 —
+ * CPU 는 감당되지만 GC 압박이 이벤트 루프로 돌아온다.
+ */
+exports.SAMPLE_LIMIT = exports.REASON_LIMIT;
+/** 표본 하나의 직렬화 상한(문자). */
+exports.RECORD_MAX = 2000;
+/**
+ * 매핑이 막고 있다고 볼 통과율 문턱.
+ *
+ * 값과 함께 내보낸다 — 화면이 「95% 미만이라 매핑 문제로 봤다」를 말할 수 있게. 숨긴 문턱은 사람이
+ * 판정을 믿지 못한다.
+ */
+exports.HEALTHY_ACCEPTED_RATIO = 0.95;
+function newIngestLedger() {
+    return {
+        window: { startMs: -1, endMs: -1, offered: 0, rejected: 0, undelivered: 0, rows: 0, flushes: 0 },
+        trend: [],
+        trendDropped: 0,
+        offered: 0,
+        rejected: 0,
+        undelivered: 0,
+        rows: 0,
+        flushes: 0,
+        lastWriteAtMs: -1,
+        lastUndeliveredAtMs: -1,
+        byReason: {},
+        reasonsCapped: false,
+        sampledReasons: new Set(),
+        samples: [],
+        sampleDropped: 0,
+        lastAtMs: -1
+    };
+}
+/**
+ * 창이 다 찼으면 닫아 추이에 넣고 새로 연다. **닫힌 창만 「최근」으로 읽는다.**
+ *
+ * ── 영속이 붙는 유일한 자리 ────────────────────────────────────────────────
+ * 닫힌 창 하나가 영속의 단위다(숫자 넷 + 구간). `onClosed` 를 받는 이유는 **이 함수가 창이 닫히는
+ * 유일한 지점**이기 때문이다 — 여기 한 곳에 붙이면 기록 경로가 갈리지 않는다.
+ *
+ * 왜 건마다가 아니라 창마다인가: 거부마다 행을 쓰면 초당 1만 행이고 그 부하가 이벤트 루프로 돌아온다.
+ * 창마다면 트윈 1,000개에 하루 14.4만 행(약 14MB)이다.
+ *
+ * `onClosed` 는 **오류를 내지 않아야 한다**(호출부가 감싼다) — 영속이 실패해도 장부는 계속 굴러야 한다.
+ * 영속을 지키는 것과 관측을 지키는 것은 다른 일이고, 뒤엣것이 앞엣것 때문에 멈추면 안 된다.
+ */
+function rollIngestWindow(ledger, nowMs, windowMs = exports.INGEST_WINDOW_MS, onClosed) {
+    if (ledger.window.startMs < 0) {
+        ledger.window.startMs = nowMs;
+        return;
+    }
+    if (nowMs - ledger.window.startMs < windowMs)
+        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 };
+    if (ledger.trend.length > exports.TREND_LIMIT) {
+        const drop = ledger.trend.length - exports.TREND_LIMIT;
+        ledger.trend.splice(0, drop);
+        ledger.trendDropped += drop;
+    }
+    /* 영속은 관측을 막지 않는다 — 터져도 장부는 이미 갱신됐다. */
+    if (onClosed) {
+        try {
+            onClosed(closed);
+        }
+        catch {
+            /* 호출부가 알린다. 여기서 삼키는 것은 **장부의 진행**을 지키기 위해서다. */
+        }
+    }
+}
+/** 사유 묶음의 키. 사유가 여럿이면 한 줄로 잇고, 없으면 지어내지 않고 `unknown`. */
+function reasonKey(errors) {
+    const list = (errors ?? []).map(e => String(e).trim()).filter(Boolean);
+    return list.length ? list.join(' · ') : 'unknown';
+}
+function safeJson(v) {
+    try {
+        const s = JSON.stringify(v);
+        return s === undefined ? String(v) : s;
+    }
+    catch {
+        return '(serialization failed)'; /* 순환 참조 등 — 모양을 못 보여 주는 것도 사실이다 */
+    }
+}
+/**
+ * 한 번의 인제스트 결과를 적는다.
+ *
+ * `offered` 를 함께 받는 이유: 통과율을 **서로 다른 두 계수기**에서 나눠 계산하면 분모와 분자가 다른
+ * 것을 세게 된다. 둘을 한자리에서 본 수를 그대로 적는다.
+ */
+function recordIngest(ledger, offered, rejected, nowMs, onClosed, 
+/** 매핑은 통과했지만 트윈에 닿지 못한 수 — 「통과」로 세면 화면이 거짓을 말한다. */
+undelivered = 0) {
+    if (!Number.isFinite(offered) || offered < 0)
+        return;
+    rollIngestWindow(ledger, nowMs, exports.INGEST_WINDOW_MS, onClosed);
+    ledger.offered += offered;
+    ledger.window.offered += offered;
+    ledger.lastAtMs = nowMs;
+    if (Number.isFinite(undelivered) && undelivered > 0) {
+        ledger.undelivered += undelivered;
+        ledger.window.undelivered += undelivered;
+        ledger.lastUndeliveredAtMs = nowMs;
+    }
+    const items = rejected ?? [];
+    if (!items.length)
+        return;
+    ledger.rejected += items.length;
+    ledger.window.rejected += items.length;
+    for (const it of items) {
+        const raw = reasonKey(it?.errors);
+        const known = raw in ledger.byReason;
+        /* 사유 종류 상한 — 넘치면 한 칸으로 접고, **닿았다는 사실**을 표시한다. */
+        let key = raw;
+        if (!known && Object.keys(ledger.byReason).length >= exports.REASON_LIMIT) {
+            key = exports.OTHER_REASON;
+            ledger.reasonsCapped = true;
+        }
+        const seen = ledger.byReason[key];
+        ledger.byReason[key] = { count: (seen?.count ?? 0) + 1, lastAtMs: nowMs };
+        /*
+         * **표본은 사유마다 하나.** 이미 그 사유의 표본이 있으면 직렬화를 아예 하지 않는다 — 초당 1만 건이
+         * 전부 거부될 때 만들자마자 버려지는 문자열을 만들지 않기 위해서다(실측: 건당 0.24µs, GC 압박).
+         */
+        if (ledger.sampledReasons.has(key)) {
+            ledger.sampleDropped += 1;
+            continue;
+        }
+        const text = safeJson(it?.record);
+        const truncated = text.length > exports.RECORD_MAX;
+        ledger.samples.push({
+            atMs: nowMs,
+            errors: key === exports.OTHER_REASON ? [exports.OTHER_REASON] : it?.errors?.length ? [...it.errors] : ['unknown'],
+            record: truncated ? text.slice(0, exports.RECORD_MAX) : text,
+            ...(truncated ? { recordTruncated: true } : {})
+        });
+        ledger.sampledReasons.add(key);
+        if (ledger.samples.length > exports.SAMPLE_LIMIT) {
+            const gone = ledger.samples.splice(0, ledger.samples.length - exports.SAMPLE_LIMIT);
+            /* 밀려난 표본의 사유는 색인에서도 빼야 다음에 다시 뜰 수 있다(안 빼면 그 사유는 영원히 표본 없음). */
+            for (const g of gone)
+                ledger.sampledReasons.delete(reasonKey(g.errors));
+            ledger.sampleDropped += gone.length;
+        }
+    }
+}
+/**
+ * 저널에 **적은 것**을 기록한다 — 창을 넘길 때가 되었으면 넘기고, 행·왕복을 더한다.
+ *
+ * ── 왜 유입과 같은 창인가 ───────────────────────────────────────────────────
+ * 새 장부를 만들지 않는다. 이 창은 「닫힌 창만 최근」·「0 과 없음을 가른다」·「잘린 것을 세어 드러낸다」를
+ * 이미 지키고, 닫힐 때 영속까지 된다. 같은 규율을 두 벌 만들면 한쪽만 고쳐진다.
+ *
+ * ── 유입이 없어도 창은 넘어간다 ────────────────────────────────────────────
+ * 시뮬 트윈은 받는 것 없이 자기가 낸 사실을 적는다. 창이 **유입에서만** 넘어간다면 그 트윈은 추이에
+ * 영원히 나타나지 않는다 — 그래서 쓰기도 창을 넘긴다.
+ */
+function recordJournalWrite(ledger, rows, nowMs, onClosed) {
+    if (!Number.isFinite(rows) || rows <= 0)
+        return;
+    rollIngestWindow(ledger, nowMs, exports.INGEST_WINDOW_MS, onClosed);
+    ledger.rows += rows;
+    ledger.flushes += 1;
+    ledger.window.rows += rows;
+    ledger.window.flushes += 1;
+    /*
+     * **`lastAtMs` 는 건드리지 않는다.** 그 값은 「마지막 유입」이고, 끊긴 피드를 가려내는 근거다. 쓰기로
+     * 갱신하면 라이브 트윈은 유입이 끊겨도 틱이 만든 델타를 계속 적으므로 **영원히 「방금 받았다」**가 되고,
+     * 「오래 끊긴 피드에 옛 창으로 초록을 내지 않는다」가 조용히 무력해진다. 축을 따로 든다.
+     */
+    ledger.lastWriteAtMs = nowMs;
+}
+function syncVerdictOf(args) {
+    /*
+     * ── 버려지고 있는 것이 가장 먼저다 ────────────────────────────────────────
+     * 트윈이 멈추면 피드는 남아 계속 레코드를 나르고, 커널은 그것을 조용히 버린다. 그 상태를 「해당 없음」
+     * 이라 부르면 **사실이 사라지는 동안 화면이 안심시킨다** — 실제로 그렇게 떴다(멈춘 트윈 옆에 「150
+     * 통과 · 100%」). 그래서 시뮬·멈춤 판정보다 먼저 본다.
+     *
+     * 시뮬 트윈에는 이 값이 서지 않는다(먹이는 피드가 없으므로 미전달도 없다). 그래서 이 순서가 시뮬에
+     * 거짓 경보를 주지 않는다.
+     */
+    if (typeof args.lastUndeliveredAtMs === 'number' &&
+        args.lastUndeliveredAtMs >= 0 &&
+        typeof args.nowMs === 'number' &&
+        args.nowMs - args.lastUndeliveredAtMs <= exports.STALE_AFTER_MS) {
+        return 'twin-not-running';
+    }
+    if (args.feedState === 'not-applicable')
+        return 'not-applicable';
+    if (args.feedState === 'detached')
+        return 'not-connected';
+    /*
+     * ── 끊긴 피드가 초록으로 남지 않게 ────────────────────────────────────────
+     * 창은 **다음 유입이 있을 때** 닫힌다. 그래서 유입이 멈추면 창도 멈추고, 「최근 창」은 멈추기 직전의
+     * 건강했던 창으로 남는다. 그 창만 보고 판정하면 **어제 죽은 피드가 오늘도 「동기화 중」**이다. 이
+     * 기능이 있는 이유가 바로 그 상태를 드러내는 것이므로, 그때 초록을 내면 목적을 놓친다.
+     *
+     * 그래서 창과 별개로 **지금까지의 침묵**을 먼저 본다. 한 창을 통째로 아무것도 받지 않았으면 그것은
+     * 「유입 없음」이다 — 실제로 그 구간의 창은 비어 있게 된다.
+     *
+     * 이 판단을 서버에 두는 이유: 소비처가 여럿(목록·연결 상세·앞으로 생길 것)이고, 화면마다 다시
+     * 판단하면 규칙이 갈라져 어떤 화면은 초록, 어떤 화면은 경고를 말한다.
+     *
+     * 한계 — 한 창(10분)보다 **느리게 긷는 원천**은 긷는 사이에 「유입 없음」으로 보인다. 장부는 원천의
+     * 주기를 모르므로 이보다 정확히 답할 수 없다. 주기를 알게 되면 그 값으로 견주는 것이 맞다.
+     */
+    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.recent)
+        return 'unknown';
+    if (args.recent.offered <= 0)
+        return 'no-traffic';
+    const ratio = (args.recent.offered - args.recent.rejected) / args.recent.offered;
+    return ratio >= (args.threshold ?? exports.HEALTHY_ACCEPTED_RATIO) ? 'syncing' : 'mapping-blocked';
+}
+function toWindowView(w, fallbackEndMs) {
+    /* 「통과」는 **트윈에 닿은** 것만이다. 버려진 것을 통과로 세면 화면이 안심시킨다. */
+    const accepted = w.offered - w.rejected - w.undelivered;
+    return {
+        from: new Date(w.startMs).toISOString(),
+        to: new Date(w.endMs >= 0 ? w.endMs : fallbackEndMs).toISOString(),
+        offered: w.offered,
+        accepted,
+        rejected: w.rejected,
+        undelivered: w.undelivered,
+        acceptedRatio: w.offered > 0 ? round4(accepted / w.offered) : null,
+        rows: w.rows,
+        flushes: w.flushes
+    };
+}
+/**
+ * 읽기용 요약.
+ *
+ * 장부가 없어도(한 번도 받지 않은 트윈) **판정은 낸다** — 피드 사실만으로 답할 수 있는 경우가 있다
+ * (`not-applicable`·`not-connected`). 그 경우 수치는 비운다: 없는 값을 0 으로 채우지 않는다.
+ *
+ * `nowMs` 를 받는 이유: 끊긴 피드를 가려내려면 「마지막 유입이 얼마나 전인가」를 봐야 하고, 그 판단을
+ * 화면이 아니라 여기서 한다(소비처마다 다시 판단하면 규칙이 갈라진다). 시험이 시각을 고정할 수 있도록
+ * 인자로 받는다.
+ */
+function ingestHealth(ledger, feedState, threshold = exports.HEALTHY_ACCEPTED_RATIO, nowMs = Date.now()) {
+    const recentRaw = ledger?.trend.length ? ledger.trend[ledger.trend.length - 1] : null;
+    /* 열린 창의 끝 시각 대체값 — 유입이 없는 장부에서 `-1` 을 시각으로 읽으면 1969년이 화면에 뜬다. */
+    const lastAnyMs = Math.max(ledger?.lastAtMs ?? -1, ledger?.lastWriteAtMs ?? -1);
+    const verdict = syncVerdictOf({
+        feedState,
+        recent: recentRaw,
+        lastAtMs: ledger?.lastAtMs ?? -1,
+        lastUndeliveredAtMs: ledger?.lastUndeliveredAtMs ?? -1,
+        nowMs,
+        threshold
+    });
+    /*
+     * **유입이 없어도 「빈 장부」가 아니다.** 시뮬 트윈은 받는 것 없이 적는다. 유입 시각만 보고 비었다고
+     * 판단하면 그 트윈의 창은 만들어져 있는데 화면에는 아무 추이도 나오지 않는다(이 축을 넣은 이유가 그것이다).
+     */
+    if (!ledger || (ledger.lastAtMs < 0 && ledger.lastWriteAtMs < 0)) {
+        return {
+            verdict,
+            threshold,
+            recent: null,
+            trend: [],
+            trendDropped: 0,
+            total: { offered: 0, accepted: 0, rejected: 0, undelivered: 0, acceptedRatio: null, rows: 0, flushes: 0 },
+            reasons: [],
+            reasonsCapped: false,
+            samples: [],
+            sampleDropped: 0,
+            lastAt: null,
+            lastWriteAt: null,
+            /*
+             * **이 짧은 답에도 단절은 실어야 한다** — 이 자리가 바로 그 트윈의 모습이다.
+             *
+             * 받은 것도 적은 것도 없는 장부는 「아직 아무 일도 없다」로 읽히는데, 원본에 닿지 못하는 트윈이
+             * 정확히 그 모습이다(읽지 못하면 받은 것도 적은 것도 없다). 여기서 떨어뜨리면 **가장 필요한
+             * 순간에** 그 사실이 사라진다 — 실측으로 원본이 끊긴 트윈이 이 경로로 답하고 있었다.
+             */
+            ...(ledger?.readFailure
+                ? {
+                    readFailure: {
+                        consecutive: ledger.readFailure.consecutive,
+                        since: new Date(ledger.readFailure.sinceMs).toISOString(),
+                        lastAt: new Date(ledger.readFailure.lastAtMs).toISOString(),
+                        reason: ledger.readFailure.reason,
+                        ...(ledger.readFailure.stream ? { stream: ledger.readFailure.stream } : {})
+                    }
+                }
+                : {})
+        };
+    }
+    /* 「통과」는 트윈에 닿은 것만이다 — 창 뷰와 같은 규칙. */
+    const accepted = ledger.offered - ledger.rejected - ledger.undelivered;
+    return {
+        verdict,
+        threshold,
+        recent: recentRaw ? toWindowView(recentRaw, lastAnyMs) : null,
+        trend: ledger.trend.map(w => toWindowView(w, lastAnyMs)),
+        trendDropped: ledger.trendDropped,
+        total: {
+            offered: ledger.offered,
+            accepted,
+            rejected: ledger.rejected,
+            undelivered: ledger.undelivered,
+            acceptedRatio: ledger.offered > 0 ? round4(accepted / ledger.offered) : null,
+            rows: ledger.rows,
+            flushes: ledger.flushes
+        },
+        reasons: Object.entries(ledger.byReason)
+            .map(([reason, v]) => ({ reason, count: v.count, lastAt: new Date(v.lastAtMs).toISOString() }))
+            .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason)),
+        reasonsCapped: ledger.reasonsCapped,
+        samples: [...ledger.samples],
+        sampleDropped: ledger.sampleDropped,
+        /* 「받은 적 없음」과 「방금 받음」을 가른다 — 적기만 하는 트윈의 유입 시각은 **없다**. */
+        lastAt: ledger.lastAtMs >= 0 ? new Date(ledger.lastAtMs).toISOString() : null,
+        lastWriteAt: ledger.lastWriteAtMs >= 0 ? new Date(ledger.lastWriteAtMs).toISOString() : null,
+        /* 닿지 못하고 있으면 그 사실을 낸다 — 없으면 필드를 만들지 않는다(빈 값이 「닿는다」로 읽히지 않게). */
+        ...(ledger.readFailure
+            ? {
+                readFailure: {
+                    consecutive: ledger.readFailure.consecutive,
+                    since: new Date(ledger.readFailure.sinceMs).toISOString(),
+                    lastAt: new Date(ledger.readFailure.lastAtMs).toISOString(),
+                    reason: ledger.readFailure.reason,
+                    ...(ledger.readFailure.stream ? { stream: ledger.readFailure.stream } : {})
+                }
+            }
+            : {})
+    };
+}
+/** 비율은 자릿수를 넉넉히 준다 — 0.999 가 1 로 반올림되면 「전부 통과」로 읽힌다. */
+const round4 = (v) => Math.round(v * 10000) / 10000;
+//# sourceMappingURL=ingest-health.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ingest-health.js","sourceRoot":"","sources":["../../server/engine/ingest-health.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * 동기화 건강 — **이 트윈이 현장과 맞춰지고 있나.** 순수(import 없음).\n *\n * ── 한 질문 ─────────────────────────────────────────────────────────────────\n * 화면에서 값이 변하지 않을 때 원인이 넷인데, 지금까지 **넷이 똑같이 보였다.**\n *   ① 피드가 붙지 않았다  ② 붙었는데 아무것도 오지 않는다\n *   ③ 오는데 전부 거부된다  ④ 정상인데 현장이 조용하다\n * ③은 특히 나쁘다 — 커넥터의 매핑이 한 글자 틀리면 트윈은 「빈 공장」이 되고, 그 사실이 서버 로그\n * 한 줄에만 남았다. 현장에 나간 사람은 로그를 뒤져야 했다.\n *\n * ── 왜 저널로는 답할 수 없나 ────────────────────────────────────────────────\n * **거부된 것은 저널에 없다** — 거부의 뜻이 그것이다. 저널을 접으면 통과한 쪽만 나온다. 거부의 추이는\n * 세는 자리를 따로 두어야 나온다. 이 장부가 그 자리다.\n *\n * ── 왜 건마다 저장하지 않나 ─────────────────────────────────────────────────\n * 라이브 계측은 초당 여러 건이다. 거부마다 행을 쓰면 그 자체가 부하가 된다(`reference-live.ts` 가\n * 이미 그렇게 적어 두었다). 그리고 이 패키지는 **`integration-base` 를 알지 않는다**(이식성 규약) —\n * 시나리오 경로가 쓰는 dead-letter 를 여기서 부를 수 없다. 그래서 **집계한다.**\n *\n * ── 통과와 거부를 함께 센다 ─────────────────────────────────────────────────\n * 거부만 그리면 「유입 없음」과 「정상」이 **둘 다 거부 0** 으로 같아 보인다. 제시 수가 있어야 갈린다.\n *\n * ── 지키는 규율 넷 ──────────────────────────────────────────────────────────\n *  ① **닫힌 창만 「최근」이다** — 채우는 중인 창은 과소 집계다(부하 계기판에서 겪었다).\n *  ② **0 과 「없음」을 가른다** — 안 받은 것은 `null`, 받았지만 거부 0 은 `0`.\n *  ③ **조용히 자르지 않는다** — 표본·추이 상한에서 밀려난 수를 함께 낸다.\n *  ④ **통과율에 1 을 함부로 쓰지 않는다** — 1,000건 중 1건 거부는 0.999 다.\n */\n\n/** 추이 창 하나 — 제시·통과·거부·미전달, 그리고 **적힌 것**을 함께 든다. */\nexport interface IngestWindow {\n  /** 창이 열린 시각(ms). */\n  startMs: number\n  /** 창이 닫힌 시각(ms). 아직 채우는 중이면 `-1`. */\n  endMs: number\n  /** 이 창에 제시된 레코드 수(거부 여부 무관). */\n  offered: number\n  /** 그중 **매핑이 거부한** 수 — 처방은 매핑을 고치는 것이다. */\n  rejected: number\n  /**\n   * 매핑은 통과했지만 **트윈에 닿지 못한** 수 — 처방은 트윈을 세우는 것이다.\n   *\n   * ── 왜 거부와 따로 세나 (2026-08-20에 겪었다) ─────────────────────────────\n   * 트윈이 라이브로 돌지 않으면 커널이 레코드를 **조용히 버린다**. 그런데 장부는 그것을 「통과」로 셌다.\n   * 화면이 「150 들어옴 · 150 통과 · 100%」라고 말하는 동안 150건은 바닥에 버려지고 있었다. 이 기능이\n   * 막으려던 바로 그것을 이 기능이 저지른 셈이다.\n   *\n   * 거부에 합치는 것도 답이 아니다 — 거부는 「매핑을 고쳐라」는 말이고, 여기서 필요한 말은 「트윈이 안\n   * 돌고 있다」다. **처방이 다르면 다른 수로 센다.**\n   */\n  undelivered: number\n  /**\n   * 이 창에 **저널에 적힌 행** 수 — 「무엇이 남았나」.\n   *\n   * 유입과 다른 축이다: 시뮬 트윈은 받는 것 없이 자기가 낸 사실을 적는다(그래서 `offered` 는 0 이고\n   * `rows` 는 0 이 아니다). 이 칸이 없으면 그 트윈의 활동은 어느 추이에도 나타나지 않는다.\n   */\n  rows: number\n  /**\n   * 그것을 적기 위해 **DB 를 두드린 횟수**(flush) — 「우리가 몇 번 갔나」.\n   *\n   * 행 수와 따로 세는 이유: 2026-08-20 에 고친 것이 바로 이 값이다(행마다 한 번 → 창당 한 번). 행만\n   * 세면 그 개선도, 되돌아가는 것도 보이지 않는다.\n   */\n  flushes: number\n}\n\n/** 거부 표본 하나 — 매핑을 고치려면 실제 모양을 봐야 한다. */\nexport interface RejectSample {\n  atMs: number\n  /** 커널이 낸 사유. 우리가 다시 쓰지 않고 그대로 옮긴다. */\n  errors: string[]\n  /** 막힌 레코드의 직렬화. 길면 자르고, 잘랐다고 표시한다. */\n  record: string\n  recordTruncated?: boolean\n}\n\nexport interface IngestLedger {\n  /** 지금 채우는 중인 창. `startMs < 0` 이면 아직 아무것도 받지 않았다. */\n  window: IngestWindow\n  /** 닫힌 창들 — 오래된 것이 앞. 상한을 넘으면 앞에서 밀려난다. */\n  trend: IngestWindow[]\n  /** 추이에서 밀려난 창 수. */\n  trendDropped: number\n  /** 누적 제시·거부·미전달. */\n  offered: number\n  rejected: number\n  undelivered: number\n  /** 누적 — 적힌 행과 두드린 횟수. */\n  rows: number\n  flushes: number\n  /**\n   * 마지막으로 **적은** 시각. 한 번도 없으면 `-1`.\n   *\n   * 유입 시각(`lastAtMs`)과 갈라 두는 이유는 위 `recordJournalWrite` 주석에 있다 — 섞으면 끊긴 피드가\n   * 초록으로 보인다.\n   */\n  lastWriteAtMs: number\n  /**\n   * 마지막으로 **버려진** 시각(ms). 한 번도 없으면 `-1`.\n   *\n   * 창과 따로 둔다: 미전달은 창이 닫히기 전에 알아야 한다(그 사이에도 사실은 계속 사라지고 있다).\n   */\n  lastUndeliveredAtMs: number\n  /** 사유별 누적 건수와 **마지막으로 그 사유가 난 시각** — 고친 사유는 시각이 멈춘다. */\n  byReason: Record<string, { count: number; lastAtMs: number }>\n  /**\n   * 사유 종류가 상한에 닿았나.\n   *\n   * **접힌 종류 수는 세지 않는다** — 그것을 세려면 이미 본 사유를 모두 기억해야 하고, 그 집합이\n   * 바로 이 상한으로 막으려던 무한한 집합이다. 접힌 **건수**는 `byReason[OTHER_REASON].count` 가 답한다.\n   */\n  reasonsCapped: boolean\n  /** 표본을 이미 뜬 사유들 — 같은 사유를 다시 직렬화하지 않기 위한 색인(O(1) 조회). */\n  sampledReasons: Set<string>\n  /** 최근 거부 표본. */\n  samples: RejectSample[]\n  /** 표본에서 밀려난 거부 건수. */\n  sampleDropped: number\n  /** 마지막으로 무엇이든 받은 시각(ms). **한 번도 없으면 `-1`** — 0 으로 두면 시각 0 과 구별되지 않는다. */\n  lastAtMs: number\n  /**\n   * **원본에 닿지 못한 사실** (2026-08-23) — 「받은 것이 없다」와 **다른 사실**이다.\n   *\n   * ── 무엇이 조용했나 ─────────────────────────────────────────────────────────\n   * 실 원본이 끊겼을 때(접속 시간 초과) 트윈의 **조회 가능한 상태 어디에도** 그 사실이 없었다.\n   * `recordIngest` 는 `onRecords` 가 불릴 때만 도달하고, 읽기가 실패하면 그 문에 오지 않는다.\n   * `TwinReference.lastError` 는 마스터 동기·접속 시험에만 적힌다.\n   *\n   * 그래서 화면이 볼 수 있는 것은 「새 사실이 없다」뿐이었고, 그것은 **「원본이 조용하다」와 구별되지\n   * 않는다.** 실증 데모 중에 원본이 끊기면 사용자가 원인을 찾을 수 없다.\n   *\n   * ── 왜 「몇 번」과 「언제부터」를 함께 두나 ──────────────────────────────────\n   * 한 번 실패한 것과 20분째 못 읽는 것은 다른 사실이다. 그 구별이 없으면 화면이 순간의 실패에 놀라거나\n   * 계속된 단절을 대수롭지 않게 말한다. 그래서 **연속 실패 수**와 **처음 실패한 시각**을 함께 든다.\n   *\n   * 성공하면 지운다 — 고쳐진 단절이 화면에 남아 있으면 그것도 거짓이다.\n   */\n  readFailure?: {\n    /** 연속 실패 수 — 성공 한 번에 0 으로 돌아간다. */\n    consecutive: number\n    /** 이 단절이 **처음** 시작된 시각(ms). 연속이 끊기면 다시 정해진다. */\n    sinceMs: number\n    /** 마지막 실패 시각(ms). */\n    lastAtMs: number\n    /** 마지막 실패의 사유 — 사람이 읽는 한 줄(원본이 준 말 그대로). */\n    reason: string\n    /** 어느 흐름에서 났나(어댑터가 말해 주면). 원본마다 흐름이 다르므로 열려 있다. */\n    stream?: string\n  }\n}\n\n/**\n * 읽기 실패를 장부에 적는다 — **받은 것이 없는 것과 가른다.**\n *\n * 연속 실패의 시작 시각을 지키는 것이 이 함수의 요점이다: 매번 새로 적으면 「20분째 못 읽는다」를\n * 말할 수 없고, 화면은 늘 「방금 실패했다」만 보게 된다.\n */\nexport function recordReadFailure(\n  ledger: IngestLedger,\n  reason: string,\n  nowMs: number,\n  stream?: string\n): void {\n  const prev = ledger.readFailure\n  ledger.readFailure = {\n    consecutive: (prev?.consecutive ?? 0) + 1,\n    sinceMs: prev?.sinceMs ?? nowMs,\n    lastAtMs: nowMs,\n    reason,\n    ...(stream ? { stream } : {})\n  }\n}\n\n/**\n * 읽기가 성공했다 — 단절 기록을 지운다.\n *\n * **빈 읽기도 성공이다**: 원본이 「새 것이 없다」고 답한 것은 닿았다는 뜻이다. 그 둘을 같게 두면\n * 조용한 원본이 끊긴 원본으로 보인다(고치려던 것의 반대 방향으로 틀린다).\n */\nexport function clearReadFailure(ledger: IngestLedger): void {\n  if (ledger.readFailure) delete ledger.readFailure\n}\n\n/** 창 길이 — 10분. 부하 계기판(10초)과 다른 값이라 이름을 따로 둔다(같은 이름이면 섞인다). */\nexport const INGEST_WINDOW_MS = 600_000\n\n/**\n * 이만큼 아무것도 오지 않으면 「유입 없음」이라 말한다.\n *\n * 창 하나와 같게 둔다 — 한 창을 통째로 비운 것은 실제로 「그 구간에 아무것도 오지 않았다」이고, 추이의\n * 그 자리도 비게 된다. 그림과 알약이 같은 말을 하게 하려면 같은 길이여야 한다.\n */\nexport const STALE_AFTER_MS = INGEST_WINDOW_MS\n\n/** 추이 보관 창 수 — 36창 × 10분 = 6시간. 「고친 것이 먹혔나」를 보기에 충분하고 메모리는 숫자 넷×36 이다. */\nexport const TREND_LIMIT = 36\n\n/**\n * 사유 종류 상한.\n *\n * **없으면 메모리가 끝없이 자란다.** 사유 문구에 레코드마다 다른 값이 섞이는 커넥터가 하나만 있어도\n * (`unknown bizStep \"PUTAWAY_X17\"`, `…X18`, …) 키가 무한히 늘어난다. 초당 1만 건 규모에서 이것은\n * 미미한 오버헤드가 아니라 누수다.\n *\n * 넘치면 `OTHER_REASON` 한 칸에 모으고 **몇 종을 접었는지 함께 낸다**(조용히 자르지 않는다).\n * 30종이면 고칠 곳을 찾기에 충분하다 — 목록을 훑는 일이 아니라 매핑 몇 줄을 고치는 일이다.\n */\nexport const REASON_LIMIT = 30\n\n/** 상한을 넘긴 사유들이 모이는 칸. */\nexport const OTHER_REASON = '(other reasons)'\n\n/**\n * 표본 상한 — **사유마다 한 건**만 든다.\n *\n * 같은 사유 20건보다 **서로 다른 사유 1건씩**이 매핑을 고치는 데 유용하다. 그리고 이 규칙이 성능을\n * 지킨다: 그 사유의 표본이 이미 있으면 `JSON.stringify` 를 **아예 하지 않는다.** 실측(레코드 241바이트)\n * 으로 건당 0.24µs 인데, 초당 1만 건이 전부 거부되면 9,980건은 만들자마자 버려지는 문자열이었다 —\n * CPU 는 감당되지만 GC 압박이 이벤트 루프로 돌아온다.\n */\nexport const SAMPLE_LIMIT = REASON_LIMIT\n\n/** 표본 하나의 직렬화 상한(문자). */\nexport const RECORD_MAX = 2000\n\n/**\n * 매핑이 막고 있다고 볼 통과율 문턱.\n *\n * 값과 함께 내보낸다 — 화면이 「95% 미만이라 매핑 문제로 봤다」를 말할 수 있게. 숨긴 문턱은 사람이\n * 판정을 믿지 못한다.\n */\nexport const HEALTHY_ACCEPTED_RATIO = 0.95\n\nexport function newIngestLedger(): IngestLedger {\n  return {\n    window: { startMs: -1, endMs: -1, offered: 0, rejected: 0, undelivered: 0, rows: 0, flushes: 0 },\n    trend: [],\n    trendDropped: 0,\n    offered: 0,\n    rejected: 0,\n    undelivered: 0,\n    rows: 0,\n    flushes: 0,\n    lastWriteAtMs: -1,\n    lastUndeliveredAtMs: -1,\n    byReason: {},\n    reasonsCapped: false,\n    sampledReasons: new Set<string>(),\n    samples: [],\n    sampleDropped: 0,\n    lastAtMs: -1\n  }\n}\n\n/**\n * 창이 다 찼으면 닫아 추이에 넣고 새로 연다. **닫힌 창만 「최근」으로 읽는다.**\n *\n * ── 영속이 붙는 유일한 자리 ────────────────────────────────────────────────\n * 닫힌 창 하나가 영속의 단위다(숫자 넷 + 구간). `onClosed` 를 받는 이유는 **이 함수가 창이 닫히는\n * 유일한 지점**이기 때문이다 — 여기 한 곳에 붙이면 기록 경로가 갈리지 않는다.\n *\n * 왜 건마다가 아니라 창마다인가: 거부마다 행을 쓰면 초당 1만 행이고 그 부하가 이벤트 루프로 돌아온다.\n * 창마다면 트윈 1,000개에 하루 14.4만 행(약 14MB)이다.\n *\n * `onClosed` 는 **오류를 내지 않아야 한다**(호출부가 감싼다) — 영속이 실패해도 장부는 계속 굴러야 한다.\n * 영속을 지키는 것과 관측을 지키는 것은 다른 일이고, 뒤엣것이 앞엣것 때문에 멈추면 안 된다.\n */\nexport function rollIngestWindow(\n  ledger: IngestLedger,\n  nowMs: number,\n  windowMs = INGEST_WINDOW_MS,\n  onClosed?: (closed: IngestWindow) => void\n): void {\n  if (ledger.window.startMs < 0) {\n    ledger.window.startMs = nowMs\n    return\n  }\n  if (nowMs - ledger.window.startMs < windowMs) return\n\n  const closed: IngestWindow = { ...ledger.window, endMs: nowMs }\n  ledger.trend.push(closed)\n  ledger.window = { startMs: nowMs, endMs: -1, offered: 0, rejected: 0, undelivered: 0, rows: 0, flushes: 0 }\n\n  if (ledger.trend.length > TREND_LIMIT) {\n    const drop = ledger.trend.length - TREND_LIMIT\n    ledger.trend.splice(0, drop)\n    ledger.trendDropped += drop\n  }\n\n  /* 영속은 관측을 막지 않는다 — 터져도 장부는 이미 갱신됐다. */\n  if (onClosed) {\n    try {\n      onClosed(closed)\n    } catch {\n      /* 호출부가 알린다. 여기서 삼키는 것은 **장부의 진행**을 지키기 위해서다. */\n    }\n  }\n}\n\n/** 사유 묶음의 키. 사유가 여럿이면 한 줄로 잇고, 없으면 지어내지 않고 `unknown`. */\nexport function reasonKey(errors: string[] | undefined): string {\n  const list = (errors ?? []).map(e => String(e).trim()).filter(Boolean)\n  return list.length ? list.join(' · ') : 'unknown'\n}\n\nfunction safeJson(v: unknown): string {\n  try {\n    const s = JSON.stringify(v)\n    return s === undefined ? String(v) : s\n  } catch {\n    return '(serialization failed)' /* 순환 참조 등 — 모양을 못 보여 주는 것도 사실이다 */\n  }\n}\n\n/**\n * 한 번의 인제스트 결과를 적는다.\n *\n * `offered` 를 함께 받는 이유: 통과율을 **서로 다른 두 계수기**에서 나눠 계산하면 분모와 분자가 다른\n * 것을 세게 된다. 둘을 한자리에서 본 수를 그대로 적는다.\n */\nexport function recordIngest(\n  ledger: IngestLedger,\n  offered: number,\n  rejected: { record?: unknown; errors?: string[] }[] | undefined,\n  nowMs: number,\n  onClosed?: (closed: IngestWindow) => void,\n  /** 매핑은 통과했지만 트윈에 닿지 못한 수 — 「통과」로 세면 화면이 거짓을 말한다. */\n  undelivered = 0\n): void {\n  if (!Number.isFinite(offered) || offered < 0) return\n\n  rollIngestWindow(ledger, nowMs, INGEST_WINDOW_MS, onClosed)\n\n  ledger.offered += offered\n  ledger.window.offered += offered\n  ledger.lastAtMs = nowMs\n\n  if (Number.isFinite(undelivered) && undelivered > 0) {\n    ledger.undelivered += undelivered\n    ledger.window.undelivered += undelivered\n    ledger.lastUndeliveredAtMs = nowMs\n  }\n\n  const items = rejected ?? []\n  if (!items.length) return\n\n  ledger.rejected += items.length\n  ledger.window.rejected += items.length\n\n  for (const it of items) {\n    const raw = reasonKey(it?.errors)\n    const known = raw in ledger.byReason\n\n    /* 사유 종류 상한 — 넘치면 한 칸으로 접고, **닿았다는 사실**을 표시한다. */\n    let key = raw\n    if (!known && Object.keys(ledger.byReason).length >= REASON_LIMIT) {\n      key = OTHER_REASON\n      ledger.reasonsCapped = true\n    }\n\n    const seen = ledger.byReason[key]\n    ledger.byReason[key] = { count: (seen?.count ?? 0) + 1, lastAtMs: nowMs }\n\n    /*\n     * **표본은 사유마다 하나.** 이미 그 사유의 표본이 있으면 직렬화를 아예 하지 않는다 — 초당 1만 건이\n     * 전부 거부될 때 만들자마자 버려지는 문자열을 만들지 않기 위해서다(실측: 건당 0.24µs, GC 압박).\n     */\n    if (ledger.sampledReasons.has(key)) {\n      ledger.sampleDropped += 1\n      continue\n    }\n\n    const text = safeJson(it?.record)\n    const truncated = text.length > RECORD_MAX\n    ledger.samples.push({\n      atMs: nowMs,\n      errors: key === OTHER_REASON ? [OTHER_REASON] : it?.errors?.length ? [...it.errors] : ['unknown'],\n      record: truncated ? text.slice(0, RECORD_MAX) : text,\n      ...(truncated ? { recordTruncated: true } : {})\n    })\n\n    ledger.sampledReasons.add(key)\n\n    if (ledger.samples.length > SAMPLE_LIMIT) {\n      const gone = ledger.samples.splice(0, ledger.samples.length - SAMPLE_LIMIT)\n      /* 밀려난 표본의 사유는 색인에서도 빼야 다음에 다시 뜰 수 있다(안 빼면 그 사유는 영원히 표본 없음). */\n      for (const g of gone) ledger.sampledReasons.delete(reasonKey(g.errors))\n      ledger.sampleDropped += gone.length\n    }\n  }\n}\n\n/**\n * 저널에 **적은 것**을 기록한다 — 창을 넘길 때가 되었으면 넘기고, 행·왕복을 더한다.\n *\n * ── 왜 유입과 같은 창인가 ───────────────────────────────────────────────────\n * 새 장부를 만들지 않는다. 이 창은 「닫힌 창만 최근」·「0 과 없음을 가른다」·「잘린 것을 세어 드러낸다」를\n * 이미 지키고, 닫힐 때 영속까지 된다. 같은 규율을 두 벌 만들면 한쪽만 고쳐진다.\n *\n * ── 유입이 없어도 창은 넘어간다 ────────────────────────────────────────────\n * 시뮬 트윈은 받는 것 없이 자기가 낸 사실을 적는다. 창이 **유입에서만** 넘어간다면 그 트윈은 추이에\n * 영원히 나타나지 않는다 — 그래서 쓰기도 창을 넘긴다.\n */\nexport function recordJournalWrite(\n  ledger: IngestLedger,\n  rows: number,\n  nowMs: number,\n  onClosed?: (closed: IngestWindow) => void\n): void {\n  if (!Number.isFinite(rows) || rows <= 0) return\n  rollIngestWindow(ledger, nowMs, INGEST_WINDOW_MS, onClosed)\n  ledger.rows += rows\n  ledger.flushes += 1\n  ledger.window.rows += rows\n  ledger.window.flushes += 1\n  /*\n   * **`lastAtMs` 는 건드리지 않는다.** 그 값은 「마지막 유입」이고, 끊긴 피드를 가려내는 근거다. 쓰기로\n   * 갱신하면 라이브 트윈은 유입이 끊겨도 틱이 만든 델타를 계속 적으므로 **영원히 「방금 받았다」**가 되고,\n   * 「오래 끊긴 피드에 옛 창으로 초록을 내지 않는다」가 조용히 무력해진다. 축을 따로 든다.\n   */\n  ledger.lastWriteAtMs = nowMs\n}\n\n/**\n * 한눈 판정.\n *\n * `not-applicable` 과 `not-connected` 를 섞지 않고, 재지 않은 것을 정상·비정상으로 채우지 않는다\n * (`unknown`). 시뮬 트윈에 「동기화 안 됨」이라 말하면 거짓 경보이고, **거짓 경보는 참 경보를 죽인다.**\n */\nexport type SyncVerdict =\n  | 'syncing' /** 유입이 있고 통과율이 문턱 이상 */\n  | 'mapping-blocked' /** 유입은 있는데 거부가 문턱을 넘는다 — 사유를 보고 매핑을 고친다 */\n  /**\n   * 들어오는데 **커널이 받지 않는다** — 사실이 사라지고 있다.\n   *\n   * ── 이름이 사실보다 좁다 (2026-08-20에 드러났다) ────────────────────────────\n   * 관측한 것은 「커널이 받지 않았다」(`ingestLive` 가 0)이고, **멈춘 것은 그 원인 중 하나일 뿐**이다.\n   * 다른 원인이 실제로 있었다: 미러로 선언된 트윈을 사람이 화면에서 시작하면 시뮬 구동으로 떴고, 그\n   * 트윈은 **돌고 있으면서** 유입을 한 건도 받지 못했다. 그때 화면은 한쪽에 「running」, 다른 쪽에\n   * 「멈춰」라고 적었고 사람은 「시작 버튼을 누르면 되겠네」라는 엉뚱한 처방으로 갔다.\n   *\n   * 그래서 **화면 문구는 관측 그대로** 적는다(「트윈에 닿지 않고 버려지는 중」). 이 키 이름은 서버·화면·\n   * 시험에 걸친 계약 문자열이라 그대로 두지만, 이름을 원인으로 읽지 않는다.\n   */\n  | 'twin-not-running'\n  | 'no-traffic' /** 피드는 붙었는데 제시가 0 — 원천·망을 본다 */\n  | 'not-connected' /** 피드 자체가 없다 — 결선한다 */\n  | 'not-applicable' /** 원본이 먹이지 않는 트윈(시뮬)·멈춘 트윈 — 물을 대상이 아니다 */\n  | 'unknown' /** 한 번도 받지 않았거나 창이 아직 닫히지 않았다 — 기다린다 */\n\nexport function syncVerdictOf(args: {\n  /** `live-feed-registry.liveFeedStateOf` 의 답을 그대로 받는다 — 판정 어휘를 두 벌 만들지 않는다. */\n  feedState: 'attached' | 'detached' | 'not-applicable'\n  /** 마지막으로 **닫힌** 창. 없으면 `null`. */\n  recent: { offered: number; rejected: number } | null\n  /** 마지막으로 무엇이든 받은 시각. 한 번도 없으면 `-1` — 0 이 아니다(0 은 1970년이다). */\n  lastAtMs?: number\n  /** 지금. `lastAtMs` 를 견줄 때만 쓴다. */\n  nowMs?: number\n  /** 마지막으로 **버려진** 시각. 한 번도 없으면 `-1`. */\n  lastUndeliveredAtMs?: number\n  threshold?: number\n}): SyncVerdict {\n  /*\n   * ── 버려지고 있는 것이 가장 먼저다 ────────────────────────────────────────\n   * 트윈이 멈추면 피드는 남아 계속 레코드를 나르고, 커널은 그것을 조용히 버린다. 그 상태를 「해당 없음」\n   * 이라 부르면 **사실이 사라지는 동안 화면이 안심시킨다** — 실제로 그렇게 떴다(멈춘 트윈 옆에 「150\n   * 통과 · 100%」). 그래서 시뮬·멈춤 판정보다 먼저 본다.\n   *\n   * 시뮬 트윈에는 이 값이 서지 않는다(먹이는 피드가 없으므로 미전달도 없다). 그래서 이 순서가 시뮬에\n   * 거짓 경보를 주지 않는다.\n   */\n  if (\n    typeof args.lastUndeliveredAtMs === 'number' &&\n    args.lastUndeliveredAtMs >= 0 &&\n    typeof args.nowMs === 'number' &&\n    args.nowMs - args.lastUndeliveredAtMs <= STALE_AFTER_MS\n  ) {\n    return 'twin-not-running'\n  }\n\n  if (args.feedState === 'not-applicable') return 'not-applicable'\n  if (args.feedState === 'detached') return 'not-connected'\n\n  /*\n   * ── 끊긴 피드가 초록으로 남지 않게 ────────────────────────────────────────\n   * 창은 **다음 유입이 있을 때** 닫힌다. 그래서 유입이 멈추면 창도 멈추고, 「최근 창」은 멈추기 직전의\n   * 건강했던 창으로 남는다. 그 창만 보고 판정하면 **어제 죽은 피드가 오늘도 「동기화 중」**이다. 이\n   * 기능이 있는 이유가 바로 그 상태를 드러내는 것이므로, 그때 초록을 내면 목적을 놓친다.\n   *\n   * 그래서 창과 별개로 **지금까지의 침묵**을 먼저 본다. 한 창을 통째로 아무것도 받지 않았으면 그것은\n   * 「유입 없음」이다 — 실제로 그 구간의 창은 비어 있게 된다.\n   *\n   * 이 판단을 서버에 두는 이유: 소비처가 여럿(목록·연결 상세·앞으로 생길 것)이고, 화면마다 다시\n   * 판단하면 규칙이 갈라져 어떤 화면은 초록, 어떤 화면은 경고를 말한다.\n   *\n   * 한계 — 한 창(10분)보다 **느리게 긷는 원천**은 긷는 사이에 「유입 없음」으로 보인다. 장부는 원천의\n   * 주기를 모르므로 이보다 정확히 답할 수 없다. 주기를 알게 되면 그 값으로 견주는 것이 맞다.\n   */\n  if (typeof args.lastAtMs === 'number' && typeof args.nowMs === 'number') {\n    if (args.lastAtMs < 0) return 'unknown' /* 붙었지만 한 번도 받지 않았다 — 기다린다 */\n    if (args.nowMs - args.lastAtMs > STALE_AFTER_MS) return 'no-traffic'\n  }\n\n  if (!args.recent) return 'unknown'\n  if (args.recent.offered <= 0) return 'no-traffic'\n\n  const ratio = (args.recent.offered - args.recent.rejected) / args.recent.offered\n  return ratio >= (args.threshold ?? HEALTHY_ACCEPTED_RATIO) ? 'syncing' : 'mapping-blocked'\n}\n\nexport interface IngestWindowView {\n  from: string\n  to: string\n  offered: number\n  /** **트윈에 닿은** 수. 제시 − 거부 − 미전달. */\n  accepted: number\n  /** 매핑이 거부한 수 — 처방은 매핑을 고치는 것. */\n  rejected: number\n  /** 매핑은 통과했으나 트윈에 닿지 못한 수 — 처방은 트윈을 세우는 것. */\n  undelivered: number\n  /** 통과율(0~1). 제시가 없으면 `null` — **1 로 채우면 「전부 통과」로 읽힌다.** */\n  acceptedRatio: number | null\n  /** 이 창에 적힌 행. */\n  rows: number\n  /** 그것을 적기 위해 DB 를 두드린 횟수 — 행당 왕복이 줄었는지 보는 값. */\n  flushes: number\n}\n\nexport interface IngestHealthView {\n  verdict: SyncVerdict\n  /** 판정에 쓴 문턱 — 화면이 왜 그 판정인지 말할 수 있게 함께 낸다. */\n  threshold: number\n  /** 마지막으로 닫힌 창. 창이 한 번도 닫히지 않았으면 `null`. */\n  recent: IngestWindowView | null\n  /** 닫힌 창들, 오래된 것부터. */\n  trend: IngestWindowView[]\n  /** 추이 상한에서 밀려난 창 수. */\n  trendDropped: number\n  /** 누적(기동 이후). */\n  total: {\n    offered: number\n    accepted: number\n    rejected: number\n    undelivered: number\n    acceptedRatio: number | null\n    /** 저널에 적힌 행과 그것을 위해 DB 를 두드린 횟수 — 기동 이후 누적. */\n    rows: number\n    flushes: number\n  }\n  /** 사유별 누적, 많은 것부터. `lastAt` 이 멈춘 사유는 이미 고쳐진 것이다. */\n  reasons: { reason: string; count: number; lastAt: string }[]\n  /** 사유 종류가 상한에 닿아 일부가 `(other reasons)` 로 접혔나. */\n  reasonsCapped: boolean\n  samples: RejectSample[]\n  sampleDropped: number\n  /** 마지막으로 무엇이든 받은 시각. 한 번도 없으면 `null`. */\n  lastAt: string | null\n  /** 마지막으로 저널에 적은 시각. 한 번도 없으면 `null` — 받은 적 없는 트윈도 이 값은 있을 수 있다. */\n  lastWriteAt: string | null\n  /**\n   * **원본에 닿지 못하고 있다** — 없으면 닿고 있다는 뜻이다(§`IngestLedger.readFailure`).\n   *\n   * 「유입 없음」과 **다른 판정**이다: 유입 없음은 원본이 조용한 것일 수 있고, 이것은 우리가 묻지도\n   * 못한 것이다. 화면은 두 문장을 다르게 말해야 한다 — 실 원본이 끊겼을 때 사용자가 원인을 찾을 수\n   * 있는지가 그 차이다.\n   */\n  readFailure?: {\n    consecutive: number\n    /** 이 단절이 시작된 시각 — 「20분째」를 말할 수 있게. */\n    since: string\n    lastAt: string\n    reason: string\n    stream?: string\n  }\n}\n\nfunction toWindowView(w: IngestWindow, fallbackEndMs: number): IngestWindowView {\n  /* 「통과」는 **트윈에 닿은** 것만이다. 버려진 것을 통과로 세면 화면이 안심시킨다. */\n  const accepted = w.offered - w.rejected - w.undelivered\n  return {\n    from: new Date(w.startMs).toISOString(),\n    to: new Date(w.endMs >= 0 ? w.endMs : fallbackEndMs).toISOString(),\n    offered: w.offered,\n    accepted,\n    rejected: w.rejected,\n    undelivered: w.undelivered,\n    acceptedRatio: w.offered > 0 ? round4(accepted / w.offered) : null,\n    rows: w.rows,\n    flushes: w.flushes\n  }\n}\n\n/**\n * 읽기용 요약.\n *\n * 장부가 없어도(한 번도 받지 않은 트윈) **판정은 낸다** — 피드 사실만으로 답할 수 있는 경우가 있다\n * (`not-applicable`·`not-connected`). 그 경우 수치는 비운다: 없는 값을 0 으로 채우지 않는다.\n *\n * `nowMs` 를 받는 이유: 끊긴 피드를 가려내려면 「마지막 유입이 얼마나 전인가」를 봐야 하고, 그 판단을\n * 화면이 아니라 여기서 한다(소비처마다 다시 판단하면 규칙이 갈라진다). 시험이 시각을 고정할 수 있도록\n * 인자로 받는다.\n */\nexport function ingestHealth(\n  ledger: IngestLedger | undefined,\n  feedState: 'attached' | 'detached' | 'not-applicable',\n  threshold = HEALTHY_ACCEPTED_RATIO,\n  nowMs: number = Date.now()\n): IngestHealthView {\n  const recentRaw = ledger?.trend.length ? ledger.trend[ledger.trend.length - 1] : null\n  /* 열린 창의 끝 시각 대체값 — 유입이 없는 장부에서 `-1` 을 시각으로 읽으면 1969년이 화면에 뜬다. */\n  const lastAnyMs = Math.max(ledger?.lastAtMs ?? -1, ledger?.lastWriteAtMs ?? -1)\n  const verdict = syncVerdictOf({\n    feedState,\n    recent: recentRaw,\n    lastAtMs: ledger?.lastAtMs ?? -1,\n    lastUndeliveredAtMs: ledger?.lastUndeliveredAtMs ?? -1,\n    nowMs,\n    threshold\n  })\n\n  /*\n   * **유입이 없어도 「빈 장부」가 아니다.** 시뮬 트윈은 받는 것 없이 적는다. 유입 시각만 보고 비었다고\n   * 판단하면 그 트윈의 창은 만들어져 있는데 화면에는 아무 추이도 나오지 않는다(이 축을 넣은 이유가 그것이다).\n   */\n  if (!ledger || (ledger.lastAtMs < 0 && ledger.lastWriteAtMs < 0)) {\n    return {\n      verdict,\n      threshold,\n      recent: null,\n      trend: [],\n      trendDropped: 0,\n      total: { offered: 0, accepted: 0, rejected: 0, undelivered: 0, acceptedRatio: null, rows: 0, flushes: 0 },\n      reasons: [],\n      reasonsCapped: false,\n      samples: [],\n      sampleDropped: 0,\n      lastAt: null,\n      lastWriteAt: null,\n      /*\n       * **이 짧은 답에도 단절은 실어야 한다** — 이 자리가 바로 그 트윈의 모습이다.\n       *\n       * 받은 것도 적은 것도 없는 장부는 「아직 아무 일도 없다」로 읽히는데, 원본에 닿지 못하는 트윈이\n       * 정확히 그 모습이다(읽지 못하면 받은 것도 적은 것도 없다). 여기서 떨어뜨리면 **가장 필요한\n       * 순간에** 그 사실이 사라진다 — 실측으로 원본이 끊긴 트윈이 이 경로로 답하고 있었다.\n       */\n      ...(ledger?.readFailure\n        ? {\n            readFailure: {\n              consecutive: ledger.readFailure.consecutive,\n              since: new Date(ledger.readFailure.sinceMs).toISOString(),\n              lastAt: new Date(ledger.readFailure.lastAtMs).toISOString(),\n              reason: ledger.readFailure.reason,\n              ...(ledger.readFailure.stream ? { stream: ledger.readFailure.stream } : {})\n            }\n          }\n        : {})\n    }\n  }\n\n  /* 「통과」는 트윈에 닿은 것만이다 — 창 뷰와 같은 규칙. */\n  const accepted = ledger.offered - ledger.rejected - ledger.undelivered\n  return {\n    verdict,\n    threshold,\n    recent: recentRaw ? toWindowView(recentRaw, lastAnyMs) : null,\n    trend: ledger.trend.map(w => toWindowView(w, lastAnyMs)),\n    trendDropped: ledger.trendDropped,\n    total: {\n      offered: ledger.offered,\n      accepted,\n      rejected: ledger.rejected,\n      undelivered: ledger.undelivered,\n      acceptedRatio: ledger.offered > 0 ? round4(accepted / ledger.offered) : null,\n      rows: ledger.rows,\n      flushes: ledger.flushes\n    },\n    reasons: Object.entries(ledger.byReason)\n      .map(([reason, v]) => ({ reason, count: v.count, lastAt: new Date(v.lastAtMs).toISOString() }))\n      .sort((a, b) => b.count - a.count || a.reason.localeCompare(b.reason)),\n    reasonsCapped: ledger.reasonsCapped,\n    samples: [...ledger.samples],\n    sampleDropped: ledger.sampleDropped,\n    /* 「받은 적 없음」과 「방금 받음」을 가른다 — 적기만 하는 트윈의 유입 시각은 **없다**. */\n    lastAt: ledger.lastAtMs >= 0 ? new Date(ledger.lastAtMs).toISOString() : null,\n    lastWriteAt: ledger.lastWriteAtMs >= 0 ? new Date(ledger.lastWriteAtMs).toISOString() : null,\n    /* 닿지 못하고 있으면 그 사실을 낸다 — 없으면 필드를 만들지 않는다(빈 값이 「닿는다」로 읽히지 않게). */\n    ...(ledger.readFailure\n      ? {\n          readFailure: {\n            consecutive: ledger.readFailure.consecutive,\n            since: new Date(ledger.readFailure.sinceMs).toISOString(),\n            lastAt: new Date(ledger.readFailure.lastAtMs).toISOString(),\n            reason: ledger.readFailure.reason,\n            ...(ledger.readFailure.stream ? { stream: ledger.readFailure.stream } : {})\n          }\n        }\n      : {})\n  }\n}\n\n/** 비율은 자릿수를 넉넉히 준다 — 0.999 가 1 로 반올림되면 「전부 통과」로 읽힌다. */\nconst round4 = (v: number) => Math.round(v * 10000) / 10000\n"]}

package/dist-server/engine/integration-coverage.d.ts

@@ -0,0 +1,76 @@
+/**
+ * 표면 하나를 커넥터가 무엇으로 처리하는가 — **각 낱말에 적용 가능한 기준과 조치할 사람이 있다.**
+ * 기준이 없으면 분류가 느낌이 되고, 조치자가 없으면 표를 읽어도 누가 움직일지 알 수 없다.
+ *
+ *  · `read`      — **지금 커넥터가 질의한다.** 기준: 커넥터 코드에 그 질의 이름이 있다(확인 가능).
+ *                  조치자: 없음(완료분).
+ *
+ *  · `todo`      — **실려야 하는 사실인데 아직 안 읽는다.** 기준 셋을 다 만족: ① 원본에 읽을 길이
+ *                  있다 ② 우리 어휘에 담을 자리가 있다 ③ 아직 안 읽는다. 조치자: **커넥터**.
+ *
+ *  · `blocked`   — **실려야 하고 담을 자리도 있는데 원본이 읽을 길을 주지 않는다.** 기준: 목록 질의가
+ *                  없거나, 있어도 필수 인자 때문에 전역으로 읽을 수 없다. 조치자: **원본 쪽**.
+ *                  `todo` 와 한 칸에 두지 않는 이유가 이것이다 — 움직여야 하는 사람이 다르다.
+ *
+ *  · `no-home`   — **원본에 길은 있는데 그 사실이 상태로 남을 자리가 없다.** 기준은 어휘가 아니라
+ *                  **상태에 반영하는 것**이다 — 이벤트 어휘에 통과할 자리가 있어도 상태에 반영되지
+ *                  않으면 사실은 남지
+ *                  않는다(오히려 더 나쁘다: 검증을 통과하므로 실은 줄 알고 잃는다).
+ *                  조치자: **커널·아키텍처** — 반영할 것인지 판단해야 한다.
+ *                  냉장 온도가 그 예다. EPCIS `SensorElement`·`sensorReport` 는 이미 있고 검증기도
+ *                  본다. **소비하는 곳이 0 이다.** 그러므로 「어휘에 자리가 없다」가 아니라 「상태에
+ *                  반영하는 곳이 없다」가 정확하고, 할 일도 자리 만들기가 아니라 그 반영이다.
+ *                  **「중요하지 않다」가 아니다.** 오히려 중요한데 못 담는다는 뜻이고, 그래서 판단이
+ *                  필요하다. 냉장 온도가 그 예다 — 식품에서 일급 사실인데 계량 어휘가 에너지 전용이다.
+ *
+ *  · `derived`   — **원본이 다른 표에서 계산해 내놓는 값.** 기준: 그 질의의 결과가 우리가 읽는(또는
+ *                  읽을) 사실로부터 계산된다. 읽으면 **같은 수를 두 곳에서 만들게 되고**, 두 수가
+ *                  갈리면 어느 것을 믿을지 알 수 없다. 조치자: 없음 — 읽지 않는 것이 정답.
+ *
+ *  · `duplicate` — **같은 사실을 다른 문으로 내놓는 것.** 기준: 목록 질의로 이미 읽는(또는 읽을) 그
+ *                  사실의 단건 드릴다운이다. 계산된 값이 아니므로 `derived` 와 다르고, 관심 밖이
+ *                  아니므로 `out-of-scope` 와도 다르다. 조치자: 없음.
+ *
+ *  · `out-of-scope` — **공장의 상태나 활동이 아니다.** 기준: 그 사실이 자리·물건·설비·사람·작업·
+ *                  오더 어디에도 해당하지 않는다(사용자 계정·세무·거래처 마스터). 조치자: 없음.
+ *
+ * 「읽지 않는다」는 결론은 정당할 수 있다(`derived`·`duplicate`·`out-of-scope`). 결함은 **분류하지
+ * 않은 것**이다 — 그것은 생각한 적이 없다는 뜻이다. 그래서 판정은 「전부 읽었나」가 아니라
+ * **「전부 판단했나」** 다.
+ */
+export type Disposition = 'read' | 'derived' | 'duplicate' | 'no-home' | 'out-of-scope' | 'blocked' | 'todo';
+/** 표면 하나에 대한 판단 — **이유가 필수다.** 이유 없는 분류는 분류한 척이다. */
+export interface SurfaceRuling {
+    disposition: Disposition;
+    /** 왜 그렇게 정했나. 사람이 읽는 한 문장. */
+    why: string;
+}
+export interface CoverageInput {
+    /** 원본이 실제로 내놓는 표면 — **원본에서 얻은 것.** 커넥터가 적은 목록이 아니다. */
+    sourceSurface: readonly string[];
+    /** 커넥터의 판단표. */
+    rulings: Readonly<Record<string, SurfaceRuling>>;
+}
+export interface CoverageReport {
+    /** 원본 표면 수. */
+    total: number;
+    /** 분류된 수. */
+    classified: number;
+    /** **분류하지 않은 표면** — 생각한 적 없는 것. 이 목록이 비어야 한다. */
+    unclassified: string[];
+    /** 판단표에는 있는데 원본에 없는 것 — 원본이 바뀌었거나 이름을 잘못 적었다. */
+    stale: string[];
+    byDisposition: Record<Disposition, string[]>;
+    /** 실어야 하는데 아직 아닌 것. 초록을 막지는 않지만 **세어 보여야** 한다. */
+    todo: string[];
+    /** 원본이 길을 주지 않아 막힌 것 — 이 목록이 곧 **원본 쪽 선결 과제**다. */
+    blocked: string[];
+}
+export declare function assessCoverage(input: CoverageInput): CoverageReport;
+/**
+ * 한 줄 요약 — 화면과 로그가 같은 문장을 쓰도록.
+ *
+ * **「전부 읽었다」고 말하지 않는다.** 말하는 것은 「전부 판단했다」다. 그리고 분류하지 않은 것이 남아
+ * 있으면 그 수를 앞세운다 — 그것이 이 축의 유일한 목적이다.
+ */
+export declare function coverageLine(r: CoverageReport): string;