@things-factory/headless-twin 10.0.15 → 10.0.18

package/dist-server/service/twin-journal/event-type-split-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-type-split-shape.js","sourceRoot":"","sources":["../../../server/service/twin-journal/event-type-split-shape.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * **이 물음이 「여러 종류를 시각순으로」인가** — 순수 판단만 여기 둔다.\n *\n * 데이터베이스를 부르지 않는다. 그래서 시험이 이 파일을 그대로 부를 수 있다(데코레이터가 없다).\n * 판단이 조회 코드 안에 섞여 있으면 그 판단만 확인할 방법이 없고, 그러면 「어떤 물음이 나눠 묻는\n * 갈래로 가는가」가 아무도 읽지 못하는 규칙이 된다.\n *\n * 실측 근거와 고침의 뜻은 `event-type-split.ts` 머리에 있다.\n */\nimport { absoluteTime } from '../../engine/read-time.js'\n\n/** 질의를 몇 개까지 나눌까 — 대상 × 종류. 이 이상이면 나누는 것이 손해다. */\nexport const MAX_SPLIT = 24\n\n/** 종류 목록의 상한 — 이보다 많으면 「이 종류만」이 아니라 사실상 전체다. */\nconst MAX_TYPES = 12\n\nexport interface SplitShape {\n  eventTypes: string[]\n  /**\n   * 공정 단계 하나로 좁힌 경우 — 그 값을 갈래마다 함께 건다.\n   *\n   * 이 필터를 만나면 갈래를 포기하던 것을 고쳤다(2026-08-29). 원장은 종류를 담아 묻고 그 위에 단계\n   * 칩을 겹치는데, 칩을 고른 순간 예전 경로로 떨어져 **고르지 않은 쪽이 더 빨랐다.**\n   *\n   * 단계 컬럼에는 색인이 없다. 그래도 느려지지 않는다 — 종류 정확일치가 색인으로 시각 순서까지 주고,\n   * 단계는 그 안에서 행마다 확인하는 조건이다(걷는 행이 그 종류의 것으로 이미 좁혀져 있다).\n   */\n  bizStep?: string\n  untilTime?: Date\n  fromTime?: Date\n}\n\n/**\n * 이 물음이 「여러 종류를 시각순으로」인가 — 아니면 `null`.\n *\n * 받는 모양\n *   `eventType` 을 `in` 으로 · 시각 상한이나 구간 · 시각 내림차순 정렬\n *\n * 보내는 모양(일반 경로로)\n *   자유 검색어 · 그 밖의 필터(축·상관 식별자·업무 단계) · 그 밖의 정렬이나 연산자\n */\nexport function splitShape(params: any, sortings: any[]): SplitShape | null {\n  const filters: any[] = Array.isArray(params?.filters) ? params.filters : []\n  if (typeof params?.search === 'string' && params.search.trim()) return null\n  if (sortings.length !== 1 || sortings[0]?.name !== 'eventTime' || sortings[0]?.desc !== true) return null\n\n  let eventTypes: string[] | undefined\n  let untilTime: Date | undefined\n  let fromTime: Date | undefined\n  let bizStep: string | undefined\n  for (const f of filters) {\n    if (f?.name === 'eventType') {\n      if (f.operator !== 'in' || !Array.isArray(f.value)) return null\n      const types: string[] = f.value.map((v: unknown) => String(v ?? '').trim()).filter((t: string) => !!t)\n      /* 하나면 나눌 것이 없다(이미 정확일치라 색인을 탄다). 너무 많으면 사실상 전체다. */\n      if (types.length < 2 || types.length > MAX_TYPES) return null\n      if (eventTypes) return null\n      eventTypes = [...new Set(types)]\n    } else if (f?.name === 'bizStep') {\n      /* 하나로 좁힌 경우만 받는다 — 여러 값이면 종류 × 단계로 갈래가 곱해진다. */\n      if (f.operator !== 'eq') return null\n      const v = String(f.value ?? '').trim()\n      if (!v) return null\n      if (bizStep) return null\n      bizStep = v\n    } else if (f?.name === 'eventTime') {\n      if (f.operator === 'lte' || f.operator === 'lt') {\n        untilTime = absoluteTime(f.value) ?? undefined\n        if (!untilTime) return null\n      } else if (f.operator === 'between' && Array.isArray(f.value)) {\n        fromTime = absoluteTime(f.value[0]) ?? undefined\n        untilTime = absoluteTime(f.value[1]) ?? undefined\n        if (!fromTime || !untilTime) return null\n      } else return null\n    } else return null\n  }\n  return eventTypes ? { eventTypes, untilTime, fromTime, bizStep } : null\n}\n\n/**\n * **나눠 물은 갈래들을 합쳐 앞에서 `limit` 개** — 이 규율이 정확성의 근거다.\n *\n * ── 왜 갈래마다 `limit` 까지 받아야 하나 ────────────────────────────────────\n * 갈래마다 `limit` 개를 받아 합치면, 합친 것의 앞 `limit` 개는 **전체에서도** 앞 `limit` 개다.\n * 어떤 갈래에서 빠진 행은 그 갈래의 `limit` 번째보다 뒤이고, 우리는 전체에서 `limit` 개만 취하므로\n * 그 행이 이 페이지에 들어올 수 없다.\n *\n * 갈래마다 **더 적게** 받으면 그 성질이 깨진다. 한 갈래가 앞을 다 차지하는 경우\n * (종류 A 의 마지막이 종류 B 의 첫째보다 앞선다) 그 갈래에서 못 받은 것이 빠지고, 결과는 구간의\n * 앞부분만 계산한 것이 된다 — 그런데 화면은 「일부만 읽었다」고만 말하고 어느 부분인지는 말하지 못한다.\n * (2026-08-28 · UX 레인이 미리 짚어 준 함정이다.)\n *\n * 그래서 이 함수는 **`limit` 미만으로 받은 갈래가 있으면 그것을 말한다** — 부르는 쪽이 그 상태로\n * 답하지 않게.\n */\nexport function mergeStreams<T>(\n  streams: readonly T[][],\n  limit: number,\n  /** 앞에 와야 하는 것이 음수 — `Array.prototype.sort` 와 같은 규약. */\n  compare: (a: T, b: T) => number\n): { items: T[]; capped: boolean; underfilled: boolean } {\n  const underfilled = streams.some(s => s.length > limit)\n  const merged = streams.flat().sort(compare)\n  return {\n    items: merged.slice(0, limit),\n    /* 합친 것이 상한을 넘었으면 더 있었다는 뜻이다 — 잘랐다는 사실을 부르는 쪽이 말해야 한다. */\n    capped: merged.length > limit || streams.some(s => s.length >= limit),\n    /* 갈래가 상한보다 많이 받아 왔다 — 있을 수 없는 일이므로 부르는 쪽이 알아야 한다. */\n    underfilled\n  }\n}\n"]}

package/dist-server/service/twin-journal/event-type-split.d.ts

@@ -0,0 +1,15 @@
+import { TwinEvent } from '../twin-event/twin-event.js';
+import { type SplitShape } from './event-type-split-shape.js';
+export interface SplitPage {
+    items: TwinEvent[];
+    nextCursor?: string;
+}
+/**
+ * 나눠 묻고 합쳐 한 페이지 — 답할 수 없으면 `null`.
+ *
+ * 이어 읽기 지점은 **모든 갈래에 같이** 건다. 그래야 합친 결과가 커서 아래에서만 나온다 — 갈래마다
+ * 다르게 걸면 어떤 종류는 이미 지나간 구간을 다시 낸다.
+ */
+export declare function eventTypeSplitPage(domainId: string, instanceIds: string[], shape: SplitShape, limit: number, 
+/** 동시각을 가리는 축 — 트윈 하나면 `revision`, 여럿이면 기본키(§`cursorTiebreak`). */
+tiebreak: 'revision' | 'id', after?: string): Promise<SplitPage | null>;

package/dist-server/service/twin-journal/event-type-split.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventTypeSplitPage = eventTypeSplitPage;
+const shell_1 = require("@things-factory/shell");
+const twin_event_js_1 = require("../twin-event/twin-event.js");
+const read_time_js_1 = require("../../engine/read-time.js");
+const event_type_split_shape_js_1 = require("./event-type-split-shape.js");
+/**
+ * 나눠 묻고 합쳐 한 페이지 — 답할 수 없으면 `null`.
+ *
+ * 이어 읽기 지점은 **모든 갈래에 같이** 건다. 그래야 합친 결과가 커서 아래에서만 나온다 — 갈래마다
+ * 다르게 걸면 어떤 종류는 이미 지나간 구간을 다시 낸다.
+ */
+async function eventTypeSplitPage(domainId, instanceIds, shape, limit, 
+/** 동시각을 가리는 축 — 트윈 하나면 `revision`, 여럿이면 기본키(§`cursorTiebreak`). */
+tiebreak, after) {
+    const pairs = instanceIds.length * shape.eventTypes.length;
+    if (!pairs || pairs > event_type_split_shape_js_1.MAX_SPLIT)
+        return null;
+    let cursor = null;
+    if (after) {
+        cursor = decodeCursorPair(after);
+        if (!cursor)
+            return null;
+    }
+    const rows = [];
+    for (const instanceId of instanceIds) {
+        for (const eventType of shape.eventTypes) {
+            const qb = (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+                .createQueryBuilder('e')
+                .where('e.domain = :domainId', { domainId })
+                .andWhere('e.instanceId = :instanceId', { instanceId })
+                /* **정확일치**가 요점이다 — 그래야 색인이 시각 순서까지 준다(§ 위 실측). */
+                .andWhere('e.eventType = :eventType', { eventType });
+            /* 단계는 색인이 아니라 행 조건이다 — 종류 정확일치가 이미 걷는 범위를 좁혀 놓았다. */
+            if (shape.bizStep)
+                qb.andWhere('e.bizStep = :bizStep', { bizStep: shape.bizStep });
+            if (shape.fromTime)
+                qb.andWhere('e.eventTime >= :fromTime', { fromTime: shape.fromTime });
+            if (shape.untilTime)
+                qb.andWhere('e.eventTime <= :untilTime', { untilTime: shape.untilTime });
+            if (cursor) {
+                qb.andWhere(`(e.eventTime < :curAt OR (e.eventTime = :curAt AND e.${tiebreak} < :curTie))`, {
+                    curAt: cursor.at,
+                    curTie: cursor.tie
+                });
+            }
+            const page = await qb
+                .orderBy('e.eventTime', 'DESC')
+                .addOrderBy(`e.${tiebreak}`, 'DESC')
+                .limit(limit)
+                .getMany()
+                .catch(() => null);
+            /* 한 갈래라도 못 읽으면 합친 결과가 반쪽이다 — 반쪽을 전부인 것처럼 내지 않는다. */
+            if (!page)
+                return null;
+            rows.push(page);
+        }
+    }
+    /*
+     * 합친다. 갈래마다 `limit` 까지 받았으므로, 합쳐서 앞의 `limit` 개는 **전체에서도** 앞의 `limit` 개다
+     * (각 갈래가 자기 안에서 정렬돼 있고 그보다 앞선 것을 빠뜨릴 수 없다).
+     */
+    const merged = rows
+        .flat()
+        .sort((a, b) => {
+        /* `getMany` 는 엔티티를 주므로 시각이 이미 날짜다 — 감싸면 드라이버 값을 손으로 읽는 모양이 된다. */
+        const at = b.eventTime.getTime() - a.eventTime.getTime();
+        if (at !== 0)
+            return at;
+        const x = a[tiebreak];
+        const y = b[tiebreak];
+        return x === y ? 0 : x < y ? 1 : -1;
+    })
+        .slice(0, limit);
+    const last = merged[merged.length - 1];
+    const nextCursor = merged.length === limit && last?.eventTime instanceof Date && last[tiebreak] !== undefined
+        ? encodeCursorPair(last.eventTime, last[tiebreak])
+        : undefined;
+    return { items: merged, nextCursor };
+}
+/** 저널 경로와 같은 커서 — `[eventTime, 동시각 축]`(§`buildNextCursor`). */
+function encodeCursorPair(at, tie) {
+    return Buffer.from(JSON.stringify([at, tie]), 'utf8').toString('base64url');
+}
+function decodeCursorPair(cursor) {
+    let values;
+    try {
+        values = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(values) || values.length !== 2)
+        return null;
+    const at = (0, read_time_js_1.absoluteTime)(values[0]);
+    const tie = values[1];
+    if (!at || (typeof tie !== 'string' && typeof tie !== 'number'))
+        return null;
+    return { at, tie };
+}
+//# sourceMappingURL=event-type-split.js.map

package/dist-server/service/twin-journal/event-type-split.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-type-split.js","sourceRoot":"","sources":["../../../server/service/twin-journal/event-type-split.ts"],"names":[],"mappings":"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","sourcesContent":["import { getRepository } from '@things-factory/shell'\n\nimport { TwinEvent } from '../twin-event/twin-event.js'\nimport { absoluteTime } from '../../engine/read-time.js'\nimport { MAX_SPLIT, type SplitShape } from './event-type-split-shape.js'\n\n/*\n * **여러 종류를 시각순으로 — 종류를 하나씩 나눠 묻는다** (2026-08-28 실측).\n *\n * ── 무엇이 느렸나 ───────────────────────────────────────────────────────────\n * 에너지 원장은 「이 여덟 종류를 시각 내림차순으로 50건」을 묻는다. 그 모양에서 sqlite 는 종류 색인을\n * **버린다**:\n *\n *   종류 IN + 시각순     SEARCH USING INDEX ix_twin_event_1 (domain, instance)   37.181초 · 결과 0건\n *   같은 조건 · 정렬 없음  SEARCH USING INDEX ix_twin_event_7 (…, event_type=?)     0.003초\n *   종류 하나 + 시각순    SEARCH USING INDEX ix_twin_event_7 (…, event_type=?)     0.003초\n *\n * 정렬을 붙이는 순간 여러 종류의 순서를 합칠 방법이 없어, 시각 색인으로 337만 행을 걸으며 행마다\n * 종류를 확인한다. 승화푸드에 에너지 사건은 0건이다 — **없는 것을 찾느라 37초**를 쓴다.\n *\n * 360 이력이 64초였던 것과 같은 부류다: **거르는 축과 정렬 축이 어긋난다.**\n *\n * ── 고침 ────────────────────────────────────────────────────────────────────\n * 종류를 **정확일치로 하나씩** 물으면 색인이 시각 순서까지 그대로 준다(정렬이 사라진다). 여덟 종류면\n * 질의 여덟 개이고 각 0.003초다. 받은 것을 시각순으로 합쳐 한 페이지를 만든다.\n *\n * 새 색인도, 새 테이블도 필요 없다 — 있는 색인을 쓰게 하는 것이 전부다.\n *\n * ── 좁게 잡는다 ─────────────────────────────────────────────────────────────\n * 이 모양이 아닌 물음은 답하지 않고(`null`) 저널의 일반 경로로 보낸다. 억지로 답하면 목록이 알리지\n * 않고 달라진다.\n *\n * ── ★ **이 갈래를 걷을 조건** ────────────────────────────────────────────────\n * 앱에서 종류를 여러 값으로 보내는 곳은 **에너지 원장 한 곳뿐**이다(2026-08-28 확인). 그 화면이\n * 종류를 하나씩 고르는 모양으로 바뀌면 이 갈래를 부르는 데가 없어진다 — 그때 **지운다.**\n *\n * 부르는 데가 없는 갈래를 들고 있으면, 그것이 무언가를 받쳐 주는 것처럼 보이면서 실제로는 아무것도\n * 하지 않는다. 지금 살려 두는 이유는 하나다: 실 고객 트윈에서 37초 질의가 돌고 있고 화면 수정은\n * 다른 레인의 일이다.\n */\n\nexport interface SplitPage {\n  items: TwinEvent[]\n  nextCursor?: string\n}\n\n/**\n * 나눠 묻고 합쳐 한 페이지 — 답할 수 없으면 `null`.\n *\n * 이어 읽기 지점은 **모든 갈래에 같이** 건다. 그래야 합친 결과가 커서 아래에서만 나온다 — 갈래마다\n * 다르게 걸면 어떤 종류는 이미 지나간 구간을 다시 낸다.\n */\nexport async function eventTypeSplitPage(\n  domainId: string,\n  instanceIds: string[],\n  shape: SplitShape,\n  limit: number,\n  /** 동시각을 가리는 축 — 트윈 하나면 `revision`, 여럿이면 기본키(§`cursorTiebreak`). */\n  tiebreak: 'revision' | 'id',\n  after?: string\n): Promise<SplitPage | null> {\n  const pairs = instanceIds.length * shape.eventTypes.length\n  if (!pairs || pairs > MAX_SPLIT) return null\n\n  let cursor: { at: Date; tie: string | number } | null = null\n  if (after) {\n    cursor = decodeCursorPair(after)\n    if (!cursor) return null\n  }\n\n  const rows: TwinEvent[][] = []\n  for (const instanceId of instanceIds) {\n    for (const eventType of shape.eventTypes) {\n      const qb = getRepository(TwinEvent)\n        .createQueryBuilder('e')\n        .where('e.domain = :domainId', { domainId })\n        .andWhere('e.instanceId = :instanceId', { instanceId })\n        /* **정확일치**가 요점이다 — 그래야 색인이 시각 순서까지 준다(§ 위 실측). */\n        .andWhere('e.eventType = :eventType', { eventType })\n      /* 단계는 색인이 아니라 행 조건이다 — 종류 정확일치가 이미 걷는 범위를 좁혀 놓았다. */\n      if (shape.bizStep) qb.andWhere('e.bizStep = :bizStep', { bizStep: shape.bizStep })\n      if (shape.fromTime) qb.andWhere('e.eventTime >= :fromTime', { fromTime: shape.fromTime })\n      if (shape.untilTime) qb.andWhere('e.eventTime <= :untilTime', { untilTime: shape.untilTime })\n      if (cursor) {\n        qb.andWhere(`(e.eventTime < :curAt OR (e.eventTime = :curAt AND e.${tiebreak} < :curTie))`, {\n          curAt: cursor.at,\n          curTie: cursor.tie\n        })\n      }\n      const page = await qb\n        .orderBy('e.eventTime', 'DESC')\n        .addOrderBy(`e.${tiebreak}`, 'DESC')\n        .limit(limit)\n        .getMany()\n        .catch(() => null)\n      /* 한 갈래라도 못 읽으면 합친 결과가 반쪽이다 — 반쪽을 전부인 것처럼 내지 않는다. */\n      if (!page) return null\n      rows.push(page)\n    }\n  }\n\n  /*\n   * 합친다. 갈래마다 `limit` 까지 받았으므로, 합쳐서 앞의 `limit` 개는 **전체에서도** 앞의 `limit` 개다\n   * (각 갈래가 자기 안에서 정렬돼 있고 그보다 앞선 것을 빠뜨릴 수 없다).\n   */\n  const merged = rows\n    .flat()\n    .sort((a: any, b: any) => {\n      /* `getMany` 는 엔티티를 주므로 시각이 이미 날짜다 — 감싸면 드라이버 값을 손으로 읽는 모양이 된다. */\n      const at = (b.eventTime as Date).getTime() - (a.eventTime as Date).getTime()\n      if (at !== 0) return at\n      const x = a[tiebreak]\n      const y = b[tiebreak]\n      return x === y ? 0 : x < y ? 1 : -1\n    })\n    .slice(0, limit)\n\n  const last: any = merged[merged.length - 1]\n  const nextCursor =\n    merged.length === limit && last?.eventTime instanceof Date && last[tiebreak] !== undefined\n      ? encodeCursorPair(last.eventTime, last[tiebreak])\n      : undefined\n\n  return { items: merged, nextCursor }\n}\n\n/** 저널 경로와 같은 커서 — `[eventTime, 동시각 축]`(§`buildNextCursor`). */\nfunction encodeCursorPair(at: Date, tie: string | number): string {\n  return Buffer.from(JSON.stringify([at, tie]), 'utf8').toString('base64url')\n}\n\nfunction decodeCursorPair(cursor: string): { at: Date; tie: string | number } | null {\n  let values: unknown\n  try {\n    values = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'))\n  } catch {\n    return null\n  }\n  if (!Array.isArray(values) || values.length !== 2) return null\n  const at = absoluteTime(values[0])\n  const tie = values[1]\n  if (!at || (typeof tie !== 'string' && typeof tie !== 'number')) return null\n  return { at, tie }\n}\n"]}

package/dist-server/service/twin-journal/journal-order.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 지난 기록 조회의 정렬 축 — **부르는 쪽이 무엇으로 물었는지에 맞춘다.**
+ *
+ * 리졸버 안에 두면 이 규칙을 확인할 방법이 소스를 글자로 전수 조회하는 것뿐이다. 규칙 자체를 부를 수 있게
+ * 밖으로 뺀다(`test/journal-order-axis.test.ts`).
+ */
+export declare function journalOrder(q: {
+    untilTime?: string | null;
+    fromTime?: string | null;
+    fromRevision?: number | null;
+    toRevision?: number | null;
+}): {
+    eventTime?: 'DESC';
+    revision: 'DESC';
+};

package/dist-server/service/twin-journal/journal-order.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.journalOrder = journalOrder;
+/**
+ * 지난 기록 조회의 정렬 축 — **부르는 쪽이 무엇으로 물었는지에 맞춘다.**
+ *
+ * 리졸버 안에 두면 이 규칙을 확인할 방법이 소스를 글자로 전수 조회하는 것뿐이다. 규칙 자체를 부를 수 있게
+ * 밖으로 뺀다(`test/journal-order-axis.test.ts`).
+ */
+function journalOrder(q) {
+    /* `revision` 으로 물었으면 그 순서가 물음의 답이다. 거르는 축과 정렬 축을 맞추는 규칙과도 같다. */
+    const byTime = q.untilTime != null || q.fromTime != null;
+    if (!byTime && (q.fromRevision != null || q.toRevision != null))
+        return { revision: 'DESC' };
+    return { eventTime: 'DESC', revision: 'DESC' };
+}
+//# sourceMappingURL=journal-order.js.map

package/dist-server/service/twin-journal/journal-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"journal-order.js","sourceRoot":"","sources":["../../../server/service/twin-journal/journal-order.ts"],"names":[],"mappings":";;AAMA,oCAaC;AAnBD;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,CAK5B;IAIC,iEAAiE;IACjE,MAAM,MAAM,GAAG,CAAC,CAAC,SAAS,IAAI,IAAI,IAAI,CAAC,CAAC,QAAQ,IAAI,IAAI,CAAA;IACxD,IAAI,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,YAAY,IAAI,IAAI,IAAI,CAAC,CAAC,UAAU,IAAI,IAAI,CAAC;QAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;IAC5F,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAA;AAChD,CAAC","sourcesContent":["/**\n * 지난 기록 조회의 정렬 축 — **부르는 쪽이 무엇으로 물었는지에 맞춘다.**\n *\n * 리졸버 안에 두면 이 규칙을 확인할 방법이 소스를 글자로 전수 조회하는 것뿐이다. 규칙 자체를 부를 수 있게\n * 밖으로 뺀다(`test/journal-order-axis.test.ts`).\n */\nexport function journalOrder(q: {\n  untilTime?: string | null\n  fromTime?: string | null\n  fromRevision?: number | null\n  toRevision?: number | null\n}): {\n  eventTime?: 'DESC'\n  revision: 'DESC'\n} {\n  /* `revision` 으로 물었으면 그 순서가 물음의 답이다. 거르는 축과 정렬 축을 맞추는 규칙과도 같다. */\n  const byTime = q.untilTime != null || q.fromTime != null\n  if (!byTime && (q.fromRevision != null || q.toRevision != null)) return { revision: 'DESC' }\n  return { eventTime: 'DESC', revision: 'DESC' }\n}\n"]}

package/dist-server/service/twin-journal/twin-journal-query.d.ts

@@ -2,13 +2,13 @@ import { ListParam } from '@things-factory/shell';
 import { TwinEvent } from '../twin-event/twin-event.js';
 import { TwinEventList } from '../twin-event/twin-event-type.js';
 export declare class TwinJournalQuery {
-    twinEvents(instanceId: string, fromRevision: number, toRevision: number, eventType: string, limit: number, context: ResolverContext, untilTime?: string): Promise<TwinEvent[]>;
+    twinEvents(instanceId: string, fromRevision: number, toRevision: number, eventType: string, limit: number, context: ResolverContext, untilTime?: string, fromTime?: string): Promise<TwinEvent[]>;
     /**
-     * 저널 목록 — things-factory 표준 목록 계약(`ListParam` → `{ items, total }`).
+     * 지난 기록 목록 — things-factory 표준 목록 계약(`ListParam` → `{ items, total }`).
      *
      * ── 왜 `twinEvents` 와 따로 두는가 ─────────────────────────────────────────
      * `twinEvents` 는 배열만 돌려준다. 화면은 자기가 받은 게 전부인지 잘린 건지 알 수 없었고, 그래서
-     * 리스트가 **조용히 잘린 채 "이게 전부" 처럼** 보였다(원장 limit 120 이 대표적). 총건수를 함께
+     * 리스트가 **알리지 않고 잘린 채 "이게 전부" 처럼** 보였다(원장 limit 120 이 대표적). 총건수를 함께
      * 주면 "48 / 12,904" 라고 말할 수 있고, 사용자는 좁혀야 한다는 사실을 안다.
      * 기존 호출자를 깨지 않으려고 `twinEvents` 는 그대로 두고 목록 계약을 새로 연다.
      *
@@ -21,13 +21,13 @@ export declare class TwinJournalQuery {
      */
     twinEventList(params: ListParam, context: ResolverContext, instanceId?: string, spaceId?: string): Promise<TwinEventList>;
     /**
-     * 업무 KPI — 시간창 처리량·소요시간·자원 점유. 저널을 **접어서** 만든다(새 계측을 주입하지 않는다).
+     * 업무 KPI — 시간창 처리량·소요시간·자원 점유. 저널을 **계산해서** 만든다(새 계측을 주입하지 않는다).
      *
      * `twinMetrics`(초당 이벤트 수 = 인프라 부하)와 **다른 것**이다: 이건 "지난 한 시간에 몇 건 처리했고
      * 한 건에 얼마나 걸렸나" 다. 이름이 비슷해 헷갈리기 쉬우므로 설명에 명시한다.
      *
      * 완료된 작업의 **시작 이벤트가 창 앞에 있을 수 있어** 조회 구간을 창보다 앞으로 넓힌다(lookback).
-     * 그래도 못 찾은 것은 결과의 `unpaired` 로 드러난다 — 평균에서 조용히 빠지면 지표가 거짓이 된다.
+     * 그래도 못 찾은 것은 결과의 `unpaired` 로 드러난다 — 평균에서 오류 없이 빠지면 지표가 거짓이 된다.
      */
     twinKpi(context: ResolverContext, spaceId?: string, instanceId?: string, 
     /** 창 시작·끝(ISO). 미지정이면 최근 1시간. */

package/dist-server/service/twin-journal/twin-journal-query.js

@@ -13,6 +13,10 @@ const index_js_1 = require("../../engine/index.js");
 const state_axes_js_1 = require("../../engine/state-axes.js");
 const attention_digest_js_1 = require("../../engine/attention-digest.js");
 const kpi_query_js_1 = require("../../engine/kpi-query.js");
+const journal_order_js_1 = require("./journal-order.js");
+const twin_subject_fast_path_js_1 = require("../twin-subject/twin-subject-fast-path.js");
+const event_type_split_js_1 = require("./event-type-split.js");
+const event_type_split_shape_js_1 = require("./event-type-split-shape.js");
 /*
  * 저널 읽기 채널 — 상향 query.
  * twinEvents : append-only 이벤트 저널 조회(Ledger/History/Entity360) — instanceId·revision 범위·eventType 필터.
@@ -39,13 +43,35 @@ function toDateValue(v) {
     return Array.isArray(v) ? v.map(one) : one(v);
 }
 let TwinJournalQuery = class TwinJournalQuery {
-    async twinEvents(instanceId, fromRevision, toRevision, eventType, limit, context, untilTime) {
+    async twinEvents(instanceId, fromRevision, toRevision, eventType, limit, context, untilTime, fromTime) {
         const where = { domain: { id: context.state.domain.id }, instanceId };
         if (eventType)
             where.eventType = eventType;
-        /* 시각 커서(untilTime, ISO) 우선 — eventTime ≤ T(공유 clock). 컬럼이 날짜라 **날짜로 넘긴다.** */
-        if (untilTime != null)
+        /*
+         * ── 구간으로 물을 수 있게 한다 (2026-08-25 실측) ────────────────────────────
+         *
+         * `untilTime` 만 있으면 **끝만 정해진 조회**다. 그러면 위쪽 경계에서 뒤로 걸어오며 종류를 하나씩
+         * 확인해야 하고, 찾는 종류가 며칠 전에 멈춘 트윈에서는 그 사이 행을 전부 열어 본다. 실측:
+         *
+         *   공정 타임라인이 부르는 방식(종류만·200건)            22.0초
+         *   같은 조회에 `untilTime` 만 더한 것                     9.7초
+         *
+         * 이유는 계획이 말한다. 종류별 시각순 인덱스가 없어서 `(domain, instanceId, eventTime)` 로 걷고
+         * 행마다 테이블을 열어 종류를 본다. 승화푸드에서 작업 사실은 8월 22일에 멈춰 있고 그 뒤로 리비전이
+         * 110만 늘었으므로, 200건에 닿기까지 그만큼을 읽고 버린다.
+         *
+         * **구간을 주면 그 범위만 걷는다**(`event_time>? AND event_time<?`). 화면은 자기가 그리는 구간을
+         * 알고 있으므로 그것을 그대로 물으면 된다 — 「전체」가 실제로는 상한에 걸린 6.7시간이었던 문제도
+         * 같은 자리에서 없어진다.
+         *
+         * 컬럼이 날짜라 **날짜로 넘긴다**(문자열로 비교하면 sqlite 에서 오류 없이 빈 결과가 나온다).
+         */
+        if (untilTime != null && fromTime != null)
+            where.eventTime = (0, typeorm_1.Between)(new Date(fromTime), new Date(untilTime));
+        else if (untilTime != null)
             where.eventTime = (0, typeorm_1.LessThanOrEqual)(new Date(untilTime));
+        else if (fromTime != null)
+            where.eventTime = (0, typeorm_1.MoreThanOrEqual)(new Date(fromTime));
         else if (fromRevision != null && toRevision != null)
             where.revision = (0, typeorm_1.Between)(fromRevision, toRevision);
         else if (fromRevision != null)
@@ -67,7 +93,7 @@ let TwinJournalQuery = class TwinJournalQuery {
          * `... FOR LAST TERM OF ORDER BY` — 시각은 인덱스(`ix_twin_event_1`)에서 순서대로 나오고
          * **동시각만** 임시 정렬한다.
          *
-         * **리비전 경로는 그대로 둔다.** 그때는 거르는 축이 `revision` 이고 정렬도 `revision` 이라 이미
+         * **`revision` 경로는 그대로 둔다.** 그때는 거르는 축이 `revision` 이고 정렬도 `revision` 이라 이미
          * 맞아 있다(`ix_twin_event_0`). 축이 어긋난 경로만 고친다 — 맞는 자리를 건드리면 그쪽이 어긋난다.
          *
          * 순서의 뜻이 **완전히 같지는 않다**(측정해서 고친 문장): `revision` 순서와 `eventTime` 순서가
@@ -75,15 +101,83 @@ let TwinJournalQuery = class TwinJournalQuery {
          * 이 목록은 사람이 이력을 훑는 화면이고 **시각순으로 보는 것이 그 화면의 뜻**이므로, 그 어긋남은
          * 결함이 아니라 오히려 맞는 순서다. 동시각의 순서를 위해 `revision` 을 둘째 축으로 남긴다.
          */
-        const order = untilTime != null ? { eventTime: 'DESC', revision: 'DESC' } : { revision: 'DESC' };
-        return (0, shell_1.getRepository)(twin_event_js_1.TwinEvent).find({ where, order, take: limit ?? 200 });
+        /*
+         * ── 아무 필터도 없을 때도 시각순으로 낸다 (2026-08-25 실측) ────────────────
+         * 이 갈래가 `revision DESC` 였다. 공정 타임라인은 필터 없이 상한만 걸고 부르므로
+         * (`loadTwinEvents(id, { eventType: 'task.status', limit })`) 그 갈래로 떨어졌다.
+         *
+         * `revision` 은 **적힌 순서**다. 연결된 시스템을 되읽는 트윈에서는 그 순서가 일어난 순서와 다르다 —
+         * 커넥터가 원본의 갱신 순서를 걷기 때문에, 원본에서 나중에 손댄 행이 4월 사실을 담고 있으면 그
+         * 행이 큰 revision 을 받는다. 승화푸드 실측:
+         *
+         *   작업 축에 있는 가장 늦은 사실      2026-08-23 03:20
+         *   revision 이 가장 큰 작업 사실      2026-04-15 10:49   ← 상한이 잡던 값
+         *
+         * 상한 안에 8월 두 달치가 들어오지 않았고, 화면은 4월 사실을 최근 것으로 그렸다.
+         *
+         * 아래 목록 계약(`twinEventList`)은 이미 시각순을 기본으로 골라 두었다(§`sortings`). 이 함수만
+         * 남아 있었다. 성능도 이유가 되지 않는다 — 시각 정렬이 인덱스를 순서대로 타는 것은 아래 실측이
+         * 말한다.
+         *
+         * `revision` 범위로 거를 때는 `revision DESC` 를 그대로 쓴다. 거르는 축과 정렬 축을 맞추는 규칙이고,
+         * 그때는 부르는 쪽이 리비전으로 말하고 있으므로 리비전 순서가 그 물음의 답이다.
+         */
+        const order = (0, journal_order_js_1.journalOrder)({ untilTime, fromTime, fromRevision, toRevision });
+        /*
+         * ── `find` 이 아니라 질의 빌더로 묻는다 (2026-08-25 실측) ───────────────────
+         *
+         * `find({ where: { domain: { id } }, order, take })` 는 관계를 가진 엔티티에서 **두 단계 질의**가
+         * 된다. 실제로 나간 SQL 이 이렇다:
+         *
+         *   SELECT DISTINCT "distinctAlias"."TwinEvent_id", …
+         *   FROM (SELECT … 모든 컬럼 … FROM twin_events WHERE …) "distinctAlias"
+         *   ORDER BY … LIMIT ?
+         *
+         * **안쪽에 상한이 없다.** 조건에 맞는 행을 전부 만들어 놓고 밖에서 자른다. 승화푸드의 작업 사실은
+         * 438,913건이고 `payload` 가 함께 실리므로, 200건을 얻는 데 그 전부를 읽었다.
+         *
+         * 실측: 같은 조회를 손으로 쓰면 0.024초, 이 함수를 통하면 12초였다. 인덱스를 새로 얹은 뒤에도
+         * 그대로였다 — 인덱스는 안쪽 질의를 도와줄 뿐이고, 문제는 안쪽이 전부를 만든다는 것이었다.
+         *
+         * 관계를 **컬럼으로** 물으면 감싸지 않는다. 이 파일의 다른 자리(`timeRange` · 최종 리비전)가 이미
+         * 그 방식이다. `getMany` 는 조인이 없으면 `DISTINCT` 를 붙이지 않는다.
+         */
+        const qb = (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+            .createQueryBuilder('e')
+            .where('e.domain = :domainId', { domainId: context.state.domain.id })
+            .andWhere('e.instanceId = :instanceId', { instanceId });
+        if (eventType)
+            qb.andWhere('e.eventType = :eventType', { eventType });
+        if (where.eventTime !== undefined) {
+            /* 조건은 위에서 이미 정했다 — 같은 판단을 두 벌로 적지 않는다. */
+            if (untilTime != null && fromTime != null) {
+                qb.andWhere('e.eventTime BETWEEN :fromTime AND :untilTime', { fromTime: new Date(fromTime), untilTime: new Date(untilTime) });
+            }
+            else if (untilTime != null) {
+                qb.andWhere('e.eventTime <= :untilTime', { untilTime: new Date(untilTime) });
+            }
+            else {
+                qb.andWhere('e.eventTime >= :fromTime', { fromTime: new Date(fromTime) });
+            }
+        }
+        else if (where.revision !== undefined) {
+            if (fromRevision != null && toRevision != null)
+                qb.andWhere('e.revision BETWEEN :from AND :to', { from: fromRevision, to: toRevision });
+            else if (fromRevision != null)
+                qb.andWhere('e.revision >= :from', { from: fromRevision });
+            else
+                qb.andWhere('e.revision <= :to', { to: toRevision });
+        }
+        for (const [column, direction] of Object.entries(order))
+            qb.addOrderBy(`e.${column}`, direction);
+        return qb.limit(limit ?? 200).getMany();
     }
     /**
-     * 저널 목록 — things-factory 표준 목록 계약(`ListParam` → `{ items, total }`).
+     * 지난 기록 목록 — things-factory 표준 목록 계약(`ListParam` → `{ items, total }`).
      *
      * ── 왜 `twinEvents` 와 따로 두는가 ─────────────────────────────────────────
      * `twinEvents` 는 배열만 돌려준다. 화면은 자기가 받은 게 전부인지 잘린 건지 알 수 없었고, 그래서
-     * 리스트가 **조용히 잘린 채 "이게 전부" 처럼** 보였다(원장 limit 120 이 대표적). 총건수를 함께
+     * 리스트가 **알리지 않고 잘린 채 "이게 전부" 처럼** 보였다(원장 limit 120 이 대표적). 총건수를 함께
      * 주면 "48 / 12,904" 라고 말할 수 있고, 사용자는 좁혀야 한다는 사실을 안다.
      * 기존 호출자를 깨지 않으려고 `twinEvents` 는 그대로 두고 목록 계약을 새로 연다.
      *
@@ -99,7 +193,7 @@ let TwinJournalQuery = class TwinJournalQuery {
         if (!instanceId && !spaceId)
             throw new Error('either instanceId or spaceId is required');
         /* 테넌트 격리 — twinKpi 와 같은 규약. 남의 트윈은 빈 결과가 아니라 명시 실패로 알린다
-         * (조용한 빈 목록은 "권한 없음" 과 "데이터 없음" 을 구분할 수 없게 만든다). */
+         * (들어온 것이 없는 빈 목록은 "권한 없음" 과 "데이터 없음" 을 구분할 수 없게 만든다). */
         if (instanceId && !(await index_js_1.TwinEngine.ownsRegistered(domain.id, instanceId))) {
             throw new Error(`twin instance not found in this tenant: ${instanceId}`);
         }
@@ -111,7 +205,16 @@ let TwinJournalQuery = class TwinJournalQuery {
         const limit = Math.min(params.pagination?.limit ?? 100, 500);
         const effective = {
             ...params,
-            pagination: { page: params.pagination?.page ?? 1, limit },
+            /*
+             * ── 이어 읽기 지점을 **잃지 않는다** (2026-08-28 실측) ─────────────────────
+             *
+             * 여기서 페이지 값을 다시 만들면서 `after` 를 빼고 있었다. 그래서 응답은 다음 지점(`nextCursor`)을
+             * 내주는데 다음 요청의 그 값은 아무 데도 쓰이지 않았고, 「더 보기」가 **1페이지를 다시 냈다.**
+             * 실측: 같은 품목의 30건을 세 번 이어 읽었더니 90건 중 60건이 되풀었다(같은 id).
+             *
+             * 오류가 나지 않는 결함이라 화면에서는 「이력이 30건뿐」이나 「같은 사건이 계속 나온다」로 보인다.
+             */
+            pagination: { page: params.pagination?.page ?? 1, limit, after: params.pagination?.after },
             /* 기본 정렬은 시각 내림차순 — 여러 트윈을 합칠 때 공통 축은 revision(트윈별 카운터)이 아니라
              * **시각**이다. revision 으로 섞으면 서로 다른 트윈의 무관한 카운터가 뒤엉킨다. */
             sortings: params.sortings?.length ? params.sortings : [{ name: 'eventTime', desc: true }],
@@ -125,6 +228,69 @@ let TwinJournalQuery = class TwinJournalQuery {
              */
             filters: (params.filters ?? []).map(f => (f.name === 'eventTime' ? { ...f, value: toDateValue(f.value) } : f))
         };
+        /*
+         * ── 대상 하나의 이력은 **파생 테이블**이 답한다 (2026-08-28 실측) ───────────
+         *
+         * 360 화면의 이력이 이 문으로 온다. 물음은 「이 품목(오더·자리·설비)의 사건을 최신순으로 30건」
+         * 인데, 저널에는 그 모양의 목차가 없다: 축으로 걸러도 시각으로 정렬하는 순간 목차를 못 쓰고,
+         * 품목과 로트가 한 문자열에 붙어 있어 품목으로는 아예 찾지 못한다. 실측 **63.998초**였다.
+         *
+         * 그 물음의 모양대로 만든 테이블이 이미 있다(`twin_subject_events`). 같은 질의가 **0.078초**다.
+         * 화면을 고치지 않고 여기서 답을 가져오는 곳만 바꾼다 — 계약도 커서도 그대로다.
+         *
+         * 맞지 않는 물음(여러 트윈·자유 검색·종류 필터·다른 정렬)이거나 파생 테이블이 그 구간을 말할 수
+         * 없으면 `null` 이 오고, 그때는 아래 저널 경로로 간다. 느리지만 온전하다.
+         */
+        if (instanceIds.length === 1) {
+            const fast = await (0, twin_subject_fast_path_js_1.readModelPage)(domain.id, instanceIds[0], effective, limit);
+            if (fast)
+                return fast;
+        }
+        /*
+         * ── **여러 종류를 시각순으로 물으면 나눠 묻는다** (2026-08-28 실측) ──────────
+         *
+         * 에너지 원장이 「이 여덟 종류를 시각 내림차순으로」를 묻는다. 그 모양에서 sqlite 는 종류 색인을
+         * 버리고 시각 색인으로 337만 행을 걸으며 행마다 종류를 확인한다 — **37.181초, 결과 0건**.
+         * 종류를 정확일치로 하나씩 물으면 색인이 시각 순서까지 주므로 **각 0.003초**다.
+         *
+         * 새 색인도 새 테이블도 필요 없다. 있는 색인(`ix_twin_event_7`)을 쓰게 하는 것이 전부다.
+         * 건수 세기는 이미 빠르다(정렬을 지우므로 같은 색인을 탄다) — 목록만 이 갈래를 탄다.
+         */
+        const tiebreak = instanceIds.length === 1 ? 'revision' : 'id';
+        const split = (0, event_type_split_shape_js_1.splitShape)(effective, effective.sortings ?? []);
+        if (split) {
+            const page = await (0, event_type_split_js_1.eventTypeSplitPage)(domain.id, instanceIds, split, limit, tiebreak, effective.pagination?.after);
+            if (page) {
+                /*
+                 * 건수는 일반 경로와 같은 방식으로 센다 — 상한까지 키만 읽는다. 이 조건은 정렬이 없어 종류
+                 * 색인을 그대로 타므로 값이 싸다(실측 0.003초).
+                 */
+                const probe = (0, shell_1.getQueryBuilderFromListParams)({
+                    repository: (0, shell_1.getRepository)(twin_event_js_1.TwinEvent),
+                    params: { ...effective, pagination: { page: 1, limit: COUNT_CAP + 1 } },
+                    domain,
+                    searchables: [],
+                    sortables: ['eventTime', 'revision', 'eventType', 'bizStep'],
+                    defaultLimit: COUNT_CAP + 1,
+                    maxLimit: COUNT_CAP + 1
+                });
+                probe.andWhere(`${probe.alias}.instanceId IN (:...instanceIds)`, { instanceIds });
+                const counted = await probe
+                    .orderBy()
+                    .select(`${probe.alias}.id`)
+                    .getRawMany()
+                    .catch(() => null);
+                const capped = !counted || counted.length > COUNT_CAP;
+                return {
+                    items: page.items,
+                    total: capped ? undefined : counted.length,
+                    capped,
+                    countCap: COUNT_CAP,
+                    nextCursor: page.nextCursor,
+                    oldestRevision: undefined
+                };
+            }
+        }
         const qb = (0, shell_1.getQueryBuilderFromListParams)({
             repository: (0, shell_1.getRepository)(twin_event_js_1.TwinEvent),
             params: effective,
@@ -134,7 +300,22 @@ let TwinJournalQuery = class TwinJournalQuery {
             /* 정렬은 인덱스가 받쳐 주는 축으로만 — 큰 저널에서 임의 컬럼 정렬은 전체 정렬 스캔이다. */
             sortables: ['eventTime', 'revision', 'eventType', 'bizStep'],
             defaultLimit: 100,
-            maxLimit: 500
+            maxLimit: 500,
+            /*
+             * ── 동시각을 가리는 축을 **두 경로가 같게** 쓴다 (2026-08-28 실측) ─────────
+             *
+             * 커서는 「이 행 다음부터」이므로 시각이 같은 행들 사이에서 무엇이 앞인지 정해야 한다. 기본값은
+             * 기본키(`id`)인데, 파생 테이블 경로는 `revision` 으로 가린다(그 테이블에 `id` 가 없다).
+             *
+             * 두 경로가 한 목록을 나눠 답하면 그 축이 달라지고, 시각이 같은 행이 많은 자리에서 **본 행이
+             * 또 나온다.** 실측: 재고 사건 2,665건이 같은 시각을 가진 트윈에서 30건씩 네 번 이어 읽어
+             * 120건 중 15건이 되풀었다.
+             *
+             * 그래서 트윈 하나를 볼 때는 `revision` 으로 가린다 — 그 트윈 안에서 유일하고 빈 값이 없다.
+             * 여러 트윈을 합쳐 보는 목록에서는 리비전이 트윈마다 따로 세는 번호라 유일하지 않으므로
+             * 기본키를 쓴다.
+             */
+            cursorTiebreak: tiebreak
         });
         /* 대상 범위는 호출자가 필터로 빼먹을 수 있는 값이 아니다 — 계약상 필수라 여기서 강제한다. */
         qb.andWhere(`${qb.alias}.instanceId IN (:...instanceIds)`, { instanceIds });
@@ -146,7 +327,7 @@ let TwinJournalQuery = class TwinJournalQuery {
          *
          * 상한을 두면 같은 답이 **0.04초**다(130배). 상한을 넘으면 정확한 수를 모르는 것이 사실이므로
          * 목록 규약의 「서버 상한에 부딪힘(total 모름)」 갈래로 낸다 — 화면은 「처음 N 건만」이라고 말하고
-         * 좁히기를 권한다. **조용히 자르지 않는다**: 상한을 넘었다는 사실을 `capped` 로 함께 낸다.
+         * 좁히기를 권한다. **알리지 않고 자르지 않는다**: 상한을 넘었다는 사실을 `capped` 로 함께 낸다.
          *
          * 왜 하위 질의로 세지 않나: 5개 드라이버에서 같이 도는 형태여야 한다(이 저장소의 절대 규칙).
          * 그래서 **키 컬럼만 상한까지 읽어 세는** 방식을 쓴다 — 색인만 읽으므로 행 본문을 만들지 않는다.
@@ -163,22 +344,50 @@ let TwinJournalQuery = class TwinJournalQuery {
         /* 상한을 넘었으면 **전체 수를 모른다** — 상한값을 전체로 적으면 화면이 거짓을 말한다. */
         const total = capped ? undefined : counted.length;
         /* 다음 커서는 **이번 페이지의 마지막 행**에서 만든다. 페이지가 상한보다 짧으면 뒤가 없다. */
-        const axes = (0, shell_1.cursorSortings)(effective.sortings, 'id');
+        const axes = (0, shell_1.cursorSortings)(effective.sortings, tiebreak);
         const nextCursor = items.length === limit ? (0, shell_1.buildNextCursor)(items[items.length - 1], axes) : undefined;
-        return { items, total, capped, countCap: COUNT_CAP, nextCursor };
+        /*
+         * ── **앞부분이 지워졌는지 함께 낸다** (2026-08-27) ─────────────────────────
+         *
+         * 보관 기간 정리가 오래된 사건을 지운다(기본 7일). 그러면 이 목록을 아무리 내려가도 어느 지점에서
+         * 기록이 끝나는데, 화면이 그것을 말하지 않으면 사람은 「이 트윈은 그때 시작했다」로 읽는다.
+         * 없었던 것과 지워진 것은 다른 사실이다.
+         *
+         * 저장하지 않고 그때그때 구한다 — 저장한 값은 실제 데이터와 어긋날 수 있고, 어긋나면 어느 쪽이
+         * 사실인지 알 수 없다. 색인 `(domain, instanceId, revision)` 의 첫 행 하나라서 값이 싸다.
+         *
+         * 트윈 하나를 물었을 때만 낸다. 여러 트윈을 합쳐 보는 목록에서는 리비전이 트윈마다 따로 세는
+         * 번호라 하나의 답이 없다.
+         */
+        let oldestRevision;
+        if (instanceIds.length === 1) {
+            const first = await (0, shell_1.getRepository)(twin_event_js_1.TwinEvent)
+                .createQueryBuilder('e')
+                .select('e.revision', 'revision')
+                .where('e.domain = :domainId', { domainId: domain.id })
+                .andWhere('e.instanceId = :instanceId', { instanceId: instanceIds[0] })
+                .orderBy('e.revision', 'ASC')
+                .limit(1)
+                .getRawOne()
+                .catch(() => null);
+            const at = Number(first?.revision);
+            if (Number.isFinite(at) && at > 0)
+                oldestRevision = at;
+        }
+        return { items, total, capped, countCap: COUNT_CAP, nextCursor, oldestRevision };
     }
     /**
-     * 업무 KPI — 시간창 처리량·소요시간·자원 점유. 저널을 **접어서** 만든다(새 계측을 주입하지 않는다).
+     * 업무 KPI — 시간창 처리량·소요시간·자원 점유. 저널을 **계산해서** 만든다(새 계측을 주입하지 않는다).
      *
      * `twinMetrics`(초당 이벤트 수 = 인프라 부하)와 **다른 것**이다: 이건 "지난 한 시간에 몇 건 처리했고
      * 한 건에 얼마나 걸렸나" 다. 이름이 비슷해 헷갈리기 쉬우므로 설명에 명시한다.
      *
      * 완료된 작업의 **시작 이벤트가 창 앞에 있을 수 있어** 조회 구간을 창보다 앞으로 넓힌다(lookback).
-     * 그래도 못 찾은 것은 결과의 `unpaired` 로 드러난다 — 평균에서 조용히 빠지면 지표가 거짓이 된다.
+     * 그래도 못 찾은 것은 결과의 `unpaired` 로 드러난다 — 평균에서 오류 없이 빠지면 지표가 거짓이 된다.
      */
     async twinKpi(context, spaceId, instanceId, fromTime, toTime, windowMinutes, buckets, lookbackMinutes, groupBy, groupLimit, compareTo, baselinePeriods, baselineStride) {
         /* 테넌트 격리 — 트윈 지정이면 소속을 확인한다. 공간 지정이면 대상 해소가 도메인 목록에서
-         * 이뤄지므로(computeTwinKpi) 남의 트윈이 섞이지 않는다. 조용한 빈 결과가 아니라 명시 실패. */
+         * 이뤄지므로(computeTwinKpi) 남의 트윈이 섞이지 않는다. 들어온 것이 없는 빈 결과가 아니라 명시 실패. */
         if (instanceId && !(await index_js_1.TwinEngine.ownsRegistered(context.state.domain.id, instanceId))) {
             throw new Error(`twin instance not found in this tenant: ${instanceId}`);
         }
@@ -206,7 +415,7 @@ let TwinJournalQuery = class TwinJournalQuery {
     async twinReplay(instanceId, untilRevision, untilTime, context, axes, attentionLimit) {
         const state = await index_js_1.TwinEngine.recover(context.state.domain.id, instanceId, untilRevision ?? undefined, untilTime ?? undefined);
         const picked = (0, state_axes_js_1.pickAxes)(state, axes);
-        /* 오타를 조용히 넘기지 않는다 — 화면이 빈 채로 뜨는 이유를 아무도 모르게 되는 것이 가장 나쁘다. */
+        /* 오타를 알리지 않고 넘기지 않는다 — 화면이 빈 채로 뜨는 이유를 아무도 모르게 되는 것이 가장 나쁘다. */
         if (picked.unknown.length)
             (0, log_js_1.twinWarn)(`[twin] twinReplay: unknown axes ignored for "${instanceId}": ${picked.unknown.join(', ')}`);
         if (!attentionLimit || !picked.state?.attentions)
@@ -225,7 +434,7 @@ let TwinJournalQuery = class TwinJournalQuery {
             throw new Error('unitsPerDay must be greater than zero');
         /*
          * 기준 주를 안 주면 **이번 주 월요일**을 쓴다. 그 주에 공휴일이 끼면 상한이 조금 낮게 나오는데,
-         * 그것은 조용한 오류가 아니라 **이번 주의 실제 가용 시간**이라 답으로서 정직하다. 평상시 상한을
+         * 그것은 들어온 것이 없는 오류가 아니라 **이번 주의 실제 가용 시간**이라 답으로서 정직하다. 평상시 상한을
          * 보려는 호출자는 평상주를 지정한다.
          */
         const base = sampleWeekStart ? Date.parse(sampleWeekStart) : Date.now();
@@ -272,7 +481,8 @@ let TwinJournalQuery = class TwinJournalQuery {
 exports.TwinJournalQuery = TwinJournalQuery;
 tslib_1.__decorate([
     (0, type_graphql_1.Query)(returns => [twin_event_js_1.TwinEvent], {
-        description: 'Read the append-only twin event journal (Ledger / History / audit), filtered and ordered by revision.'
+        description: 'Read the append-only twin event journal (Ledger / History / audit). Newest first by event time; ' +
+            'ordered by revision only when a revision range is given.'
     }),
     tslib_1.__param(0, (0, type_graphql_1.Arg)('instanceId')),
     tslib_1.__param(1, (0, type_graphql_1.Arg)('fromRevision', type => type_graphql_1.Int, { nullable: true })),
@@ -281,8 +491,9 @@ tslib_1.__decorate([
     tslib_1.__param(4, (0, type_graphql_1.Arg)('limit', type => type_graphql_1.Int, { nullable: true })),
     tslib_1.__param(5, (0, type_graphql_1.Ctx)()),
     tslib_1.__param(6, (0, type_graphql_1.Arg)('untilTime', { nullable: true })),
+    tslib_1.__param(7, (0, type_graphql_1.Arg)('fromTime', { nullable: true })),
     tslib_1.__metadata("design:type", Function),
-    tslib_1.__metadata("design:paramtypes", [String, Number, Number, String, Number, Object, String]),
+    tslib_1.__metadata("design:paramtypes", [String, Number, Number, String, Number, Object, String, String]),
     tslib_1.__metadata("design:returntype", Promise)
 ], TwinJournalQuery.prototype, "twinEvents", null);
 tslib_1.__decorate([