@things-factory/ops-master 10.0.19 → 10.1.0

package/dist-server/service/master-conformance.js

@@ -0,0 +1,266 @@
+"use strict";
+/**
+ * 마스터가 **말이 되나** — 축을 가로질러 한 번에 본다.
+ *
+ * ── 왜 필요한가 ────────────────────────────────────────────────────────────
+ * 축마다 화면이 있고 축마다 값이 차 있는데, 그 사이가 이어지는지는 아무도 안 봤다. 설비 등급 다섯이
+ * 서 있고 설비 스물둘이 어느 등급에도 안 들어 있던 일이 그랬다 — 두 화면 다 멀쩡해 보였다.
+ * 카메라 자산 다섯이 ECU 등급에 들어 있던 것도, 정지 사유 고르기가 빈 목록으로 보이던 것도 같다.
+ *
+ * 사람이 열두 화면을 오가며 맞춰 보는 것으로는 안 된다. 맞춰 보지 않으면 아무도 모르고, 맞춰 봤는지
+ * 아닌지도 남지 않는다.
+ *
+ * ── 두 가지만 본다 ─────────────────────────────────────────────────────────
+ * **비어 있으면 안 되는 칸**과 **가리키는데 없는 것**이다. 둘 다 사실 판정이라 다툼이 없다.
+ * 「이 값이 옳은가」는 여기서 안 본다 — 그것은 현장이 정한다.
+ *
+ * ── 없는 것을 없다고 말한다 ────────────────────────────────────────────────
+ * 표가 통째로 비었으면 그것도 낸다. 「빠진 것 0건」과 「아직 아무것도 안 세웠다」는 다르고, 세지
+ * 않으면 둘이 같아 보인다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkMaster = checkMaster;
+exports.scannedCounts = scannedCounts;
+exports.summarize = summarize;
+exports.readMasterSnapshot = readMasterSnapshot;
+const nameSet = (rows) => new Set(rows.map(one => one.name).filter(Boolean));
+/** 값이 비었나 — 빈 문자열과 빈 배열도 빈 것으로 본다. */
+function blank(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    return String(value).trim() === '';
+}
+/** 이름 목록으로 만든다 — 한 개짜리 문자열도, 배열도 같게 다룬다. */
+function asList(value) {
+    if (blank(value)) {
+        return [];
+    }
+    return (Array.isArray(value) ? value : [value]).map(one => String(one).trim()).filter(Boolean);
+}
+/**
+ * 축 하나를 잰다.
+ *
+ * `required` 는 비어 있으면 안 되는 칸, `refs` 는 「이 칸의 값이 저 이름들 안에 있어야 한다」이다.
+ */
+function checkAxis(axis, rows, required, refs) {
+    const found = [];
+    if (rows.length === 0) {
+        /* 표가 통째로 비었다. 「빠진 것 0건」과 다르다. */
+        return [{ axis, kind: 'empty', field: axis }];
+    }
+    for (const row of rows) {
+        for (const field of required) {
+            if (blank(row[field])) {
+                found.push({ axis, subject: row.name, kind: 'missing', field });
+            }
+        }
+        for (const { field, within } of refs) {
+            for (const value of asList(row[field])) {
+                if (!within.has(value)) {
+                    found.push({ axis, subject: row.name, kind: 'dangling', field, value });
+                }
+            }
+        }
+    }
+    return found;
+}
+/** 아무도 안 가리키는 것들 — 세워 놓고 쓰지 않는 선언. */
+function checkUnused(axis, rows, pointedAt, field) {
+    return rows
+        .filter(one => one.name && !pointedAt.has(one.name))
+        .map(one => ({ axis, subject: one.name, kind: 'unused', field }));
+}
+/**
+ * 마스터 전체를 잰다.
+ *
+ * **순서에 뜻이 없다.** 어느 축부터 보든 같은 답이 나와야 하고, 그래야 이 결과를 두 번 재서
+ * 견줄 수 있다.
+ */
+function checkMaster(snapshot) {
+    const locations = nameSet(snapshot.operationalLocations);
+    const operations = nameSet(snapshot.operationDefinitions);
+    const routes = nameSet(snapshot.routeDefinitions);
+    const materials = nameSet(snapshot.materialDefinitions);
+    const specs = nameSet(snapshot.testSpecifications);
+    const personnelClasses = nameSet(snapshot.personnelClasses);
+    const equipmentClasses = nameSet(snapshot.equipmentClasses);
+    const assetClasses = nameSet(snapshot.physicalAssetClasses);
+    const materialClasses = nameSet(snapshot.materialClasses);
+    const stopReasons = nameSet(snapshot.stopReasons);
+    const found = [
+        ...checkAxis('person', snapshot.persons, ['personnelClassIds', 'homeLocation'], [
+            { field: 'personnelClassIds', within: personnelClasses },
+            { field: 'homeLocation', within: locations },
+            { field: 'testSpecificationIds', within: specs }
+        ]),
+        ...checkAxis('equipment', snapshot.equipment, ['kind', 'homeLocation', 'equipmentClassIds'], [
+            { field: 'equipmentClassIds', within: equipmentClasses },
+            { field: 'homeLocation', within: locations },
+            { field: 'testSpecificationIds', within: specs }
+        ]),
+        ...checkAxis('physicalAsset', snapshot.physicalAssets, ['assetClassIds'], [
+            { field: 'assetClassIds', within: assetClasses },
+            { field: 'homeLocation', within: locations },
+            { field: 'testSpecificationIds', within: specs }
+        ]),
+        ...checkAxis('materialDefinition', snapshot.materialDefinitions, ['materialClassIds'], [
+            { field: 'materialClassIds', within: materialClasses },
+            { field: 'testSpecificationIds', within: specs }
+        ]),
+        /*
+         * 공정의 `resourceType` 은 설비 **종류**를 가리키는 값이라 이름 집합이 없다. 여기서는
+         * 비었는지만 본다 — 없는 것을 있는 척 검사하지 않는다.
+         */
+        ...checkAxis('operationDefinition', snapshot.operationDefinitions, ['intent', 'locationType', 'duration'], []),
+        ...checkAxis('routeDefinition', snapshot.routeDefinitions, ['steps'], [
+            { field: 'steps', within: operations }
+        ]),
+        ...checkAxis('recipeDefinition', snapshot.recipeDefinitions, ['materialDefinitionName', 'route', 'inputs'], [
+            { field: 'materialDefinitionName', within: materials },
+            { field: 'route', within: routes }
+        ]),
+        ...checkAxis('operationalLocation', snapshot.operationalLocations, ['type', 'level'], [
+            { field: 'parentId', within: locations }
+        ]),
+        ...checkAxis('stopReason', snapshot.stopReasons, ['status'], [{ field: 'parentName', within: stopReasons }]),
+        ...checkAxis('testSpecification', snapshot.testSpecifications, ['criteria'], [])
+    ];
+    /*
+     * 제조법의 투입은 한 줄이 여럿을 가리킨다. 위의 검사는 칸 하나를 보므로 여기서 따로 본다.
+     */
+    for (const recipe of snapshot.recipeDefinitions) {
+        for (const part of recipe.inputs ?? []) {
+            if (part?.material && !materials.has(part.material)) {
+                found.push({ axis: 'recipeDefinition', subject: recipe.name, kind: 'dangling', field: 'inputs.material', value: part.material });
+            }
+            if (part?.operation && !operations.has(part.operation)) {
+                found.push({ axis: 'recipeDefinition', subject: recipe.name, kind: 'dangling', field: 'inputs.operation', value: part.operation });
+            }
+        }
+    }
+    /*
+     * ── 세워 놓고 아무도 안 든 등급 ─────────────────────────────────────────
+     *
+     * **상속을 타고 센다.** 등급은 등급을 상속하고(`baseIds`), 자격 판정도 그 사슬을 닫아서 본다
+     * (커널의 `classClosure`). 그러니 「아무도 안 든다」도 닫힌 소속으로 물어야 한다.
+     *
+     * 직접 소속만 세면 뿌리 등급이 늘 걸린다. 품목의 유형 등급(완제품 · 반제품 · 원재료)이 그렇다 —
+     * 품목은 성격 등급에 들고 그 등급이 유형을 상속하므로, 직접 소속은 언제나 0이다. 그것을 결함으로
+     * 읽으면 멀쩡한 등급을 지우러 간다.
+     *
+     * 처음에는 품목만 따로 다뤘고 나머지 셋은 직접 소속으로 셌다. 아키텍트 레인이 설비 등급에도
+     * 같은 축이 있다고 알려 주어 넷을 한 규칙으로 모았다 — 축마다 다르게 세면 한쪽만 고쳐지는 날이
+     * 온다. [재봤음] 2026-09-04
+     */
+    const classAxes = [
+        ['personnelClass', snapshot.personnelClasses, snapshot.persons, 'personnelClassIds'],
+        ['equipmentClass', snapshot.equipmentClasses, snapshot.equipment, 'equipmentClassIds'],
+        ['physicalAssetClass', snapshot.physicalAssetClasses, snapshot.physicalAssets, 'assetClassIds'],
+        ['materialClass', snapshot.materialClasses, snapshot.materialDefinitions, 'materialClassIds']
+    ];
+    for (const [axis, classes, members, field] of classAxes) {
+        found.push(...checkUnused(axis, classes, closedMembership(classes, members, field), 'members'));
+    }
+    /* 아무도 안 가리키는 라우팅·공정. 만들어 놓고 안 쓰는 것은 지워도 되는 것인지 사람이 판단한다. */
+    const routesUsed = new Set(snapshot.recipeDefinitions.map(one => one.route).filter(Boolean));
+    const operationsUsed = new Set([
+        ...snapshot.routeDefinitions.flatMap(one => asList(one.steps)),
+        ...snapshot.recipeDefinitions.flatMap(one => (one.inputs ?? []).map((part) => part?.operation).filter(Boolean))
+    ]);
+    found.push(...checkUnused('routeDefinition', snapshot.routeDefinitions, routesUsed, 'usedByRecipes'), ...checkUnused('operationDefinition', snapshot.operationDefinitions, operationsUsed, 'usedInRoutes'));
+    return found;
+}
+/**
+ * **닫힌 소속** — 소속이 상속을 타고 닿는 등급까지 모은다.
+ *
+ * 사람이 `welding-robot-6axis` 에 들고 그것이 `welding-equipment` 를 상속하면, 두 등급 다 「누가
+ * 들었다」로 센다. 자격 판정이 그 사슬을 닫아서 보므로(커널의 `classClosure`) 여기서도 같게 본다.
+ *
+ * **고리를 밟으면 멈춘다.** `baseIds` 는 화면에서 손으로 넣을 수 있어 A→B→A 가 생길 수 있다.
+ */
+function closedMembership(classes, members, field) {
+    const baseOf = new Map(classes.map(one => [one.name, asList(one.baseIds)]));
+    const reached = new Set();
+    const walk = (name) => {
+        if (!name || reached.has(name)) {
+            return;
+        }
+        reached.add(name);
+        for (const base of baseOf.get(name) ?? []) {
+            walk(base);
+        }
+    };
+    for (const row of members) {
+        for (const name of asList(row[field])) {
+            walk(name);
+        }
+    }
+    return reached;
+}
+/** 여러 줄이 가리키는 이름들을 모은다. */
+function collect(rows, field) {
+    return new Set(rows.flatMap(one => asList(one[field])));
+}
+/**
+ * **무엇을 몇 개 봤나.**
+ *
+ * 어긋남 0건이 「멀쩡하다」인지 「안 돌았다」인지는 이것으로만 갈린다. 본 수를 안 내면 두 답이
+ * 같은 글자로 나온다 — 검사기가 스스로를 못 믿게 만드는 가장 흔한 방식이다.
+ */
+function scannedCounts(snapshot) {
+    return Object.entries(snapshot)
+        .map(([axis, rows]) => ({ axis, rows: rows.length }))
+        .sort((a, b) => a.axis.localeCompare(b.axis));
+}
+/** 축·종류별로 몇 건인지. 사람이 먼저 볼 것을 고르는 데 쓴다. */
+function summarize(findings) {
+    const tally = new Map();
+    for (const one of findings) {
+        const key = `${one.axis}${one.kind}`;
+        tally.set(key, (tally.get(key) ?? 0) + 1);
+    }
+    return [...tally.entries()]
+        .map(([key, count]) => {
+        const [axis, kind] = key.split('');
+        return { axis, kind, count };
+    })
+        .sort((a, b) => b.count - a.count || a.axis.localeCompare(b.axis));
+}
+/**
+ * 한 도메인의 마스터를 통째로 읽어 잰다.
+ *
+ * **상한을 두지 않는다.** 정합성은 「전부 봤나」가 곧 답이라, 일부만 보고 「어긋남 0건」이라고 하면
+ * 그 답이 거짓이 된다. 그래서 이것은 목록 화면이 부르는 것이 아니라 **사람이 눌러서 도는 검사**다.
+ */
+async function readMasterSnapshot(domain, getRepository, entities) {
+    const all = async (Entity, select) => (await getRepository(Entity).find({
+        where: { domain: { id: domain.id } },
+        select: ['id', 'name', ...select]
+    }));
+    const [persons, equipment, physicalAssets, materialDefinitions, operationDefinitions, routeDefinitions, recipeDefinitions, operationalLocations, stopReasons, testSpecifications, personnelClasses, equipmentClasses, physicalAssetClasses, materialClasses] = await Promise.all([
+        all(entities.Person, ['personnelClassIds', 'homeLocation', 'testSpecificationIds']),
+        all(entities.Equipment, ['kind', 'homeLocation', 'equipmentClassIds', 'testSpecificationIds']),
+        all(entities.PhysicalAsset, ['assetClassIds', 'homeLocation', 'testSpecificationIds']),
+        all(entities.MaterialDefinition, ['materialClassIds', 'testSpecificationIds']),
+        all(entities.OperationDefinition, ['intent', 'locationType', 'resourceType', 'duration']),
+        all(entities.RouteDefinition, ['steps']),
+        all(entities.RecipeDefinition, ['materialDefinitionName', 'route', 'inputs']),
+        all(entities.OperationalLocation, ['type', 'level', 'parentId']),
+        all(entities.StopReason, ['status', 'parentName']),
+        all(entities.TestSpecification, ['criteria']),
+        all(entities.PersonnelClass, ['baseIds']),
+        all(entities.EquipmentClass, ['baseIds']),
+        all(entities.PhysicalAssetClass, ['baseIds']),
+        all(entities.MaterialClass, ['baseIds'])
+    ]);
+    return {
+        persons, equipment, physicalAssets, materialDefinitions, operationDefinitions,
+        routeDefinitions, recipeDefinitions, operationalLocations, stopReasons, testSpecifications,
+        personnelClasses, equipmentClasses, physicalAssetClasses, materialClasses
+    };
+}
+//# sourceMappingURL=master-conformance.js.map

package/dist-server/service/master-conformance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-conformance.js","sourceRoot":"","sources":["../../server/service/master-conformance.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * 마스터가 **말이 되나** — 축을 가로질러 한 번에 본다.\n *\n * ── 왜 필요한가 ────────────────────────────────────────────────────────────\n * 축마다 화면이 있고 축마다 값이 차 있는데, 그 사이가 이어지는지는 아무도 안 봤다. 설비 등급 다섯이\n * 서 있고 설비 스물둘이 어느 등급에도 안 들어 있던 일이 그랬다 — 두 화면 다 멀쩡해 보였다.\n * 카메라 자산 다섯이 ECU 등급에 들어 있던 것도, 정지 사유 고르기가 빈 목록으로 보이던 것도 같다.\n *\n * 사람이 열두 화면을 오가며 맞춰 보는 것으로는 안 된다. 맞춰 보지 않으면 아무도 모르고, 맞춰 봤는지\n * 아닌지도 남지 않는다.\n *\n * ── 두 가지만 본다 ─────────────────────────────────────────────────────────\n * **비어 있으면 안 되는 칸**과 **가리키는데 없는 것**이다. 둘 다 사실 판정이라 다툼이 없다.\n * 「이 값이 옳은가」는 여기서 안 본다 — 그것은 현장이 정한다.\n *\n * ── 없는 것을 없다고 말한다 ────────────────────────────────────────────────\n * 표가 통째로 비었으면 그것도 낸다. 「빠진 것 0건」과 「아직 아무것도 안 세웠다」는 다르고, 세지\n * 않으면 둘이 같아 보인다.\n */\n\n/** 한 건의 어긋남. 사실만 담는다 — 무엇을, 어디서, 무엇이. */\nexport interface Finding {\n  /** 어느 축인가. `person` · `equipment` · `recipeDefinition` … */\n  axis: string\n  /** 어느 줄인가. 표가 통째로 빈 경우에는 없다. */\n  subject?: string\n  /** `missing` = 비어 있으면 안 되는 칸이 비었다 · `dangling` = 가리키는데 그런 것이 없다 · `empty` = 표가 비었다 · `unused` = 아무도 안 가리킨다 */\n  kind: 'missing' | 'dangling' | 'empty' | 'unused'\n  /** 어느 칸인가(`missing`·`dangling`), 또는 무엇이 비었나(`empty`·`unused`). */\n  field: string\n  /** 가리키던 값. `dangling` 일 때만. */\n  value?: string\n}\n\n/** 한 축이 내놓는 줄들. 이름과 칸 몇 개만 본다. */\nexport type Row = Record<string, any>\n\nexport interface MasterSnapshot {\n  persons: Row[]\n  equipment: Row[]\n  physicalAssets: Row[]\n  materialDefinitions: Row[]\n  operationDefinitions: Row[]\n  routeDefinitions: Row[]\n  recipeDefinitions: Row[]\n  operationalLocations: Row[]\n  stopReasons: Row[]\n  testSpecifications: Row[]\n  personnelClasses: Row[]\n  equipmentClasses: Row[]\n  physicalAssetClasses: Row[]\n  materialClasses: Row[]\n}\n\nconst nameSet = (rows: Row[]) => new Set(rows.map(one => one.name).filter(Boolean))\n\n/** 값이 비었나 — 빈 문자열과 빈 배열도 빈 것으로 본다. */\nfunction blank(value: any): boolean {\n  if (value === null || value === undefined) {\n    return true\n  }\n  if (Array.isArray(value)) {\n    return value.length === 0\n  }\n\n  return String(value).trim() === ''\n}\n\n/** 이름 목록으로 만든다 — 한 개짜리 문자열도, 배열도 같게 다룬다. */\nfunction asList(value: any): string[] {\n  if (blank(value)) {\n    return []\n  }\n\n  return (Array.isArray(value) ? value : [value]).map(one => String(one).trim()).filter(Boolean)\n}\n\n/**\n * 축 하나를 잰다.\n *\n * `required` 는 비어 있으면 안 되는 칸, `refs` 는 「이 칸의 값이 저 이름들 안에 있어야 한다」이다.\n */\nfunction checkAxis(\n  axis: string,\n  rows: Row[],\n  required: string[],\n  refs: { field: string; within: Set<string> }[]\n): Finding[] {\n  const found: Finding[] = []\n\n  if (rows.length === 0) {\n    /* 표가 통째로 비었다. 「빠진 것 0건」과 다르다. */\n    return [{ axis, kind: 'empty', field: axis }]\n  }\n\n  for (const row of rows) {\n    for (const field of required) {\n      if (blank(row[field])) {\n        found.push({ axis, subject: row.name, kind: 'missing', field })\n      }\n    }\n\n    for (const { field, within } of refs) {\n      for (const value of asList(row[field])) {\n        if (!within.has(value)) {\n          found.push({ axis, subject: row.name, kind: 'dangling', field, value })\n        }\n      }\n    }\n  }\n\n  return found\n}\n\n/** 아무도 안 가리키는 것들 — 세워 놓고 쓰지 않는 선언. */\nfunction checkUnused(axis: string, rows: Row[], pointedAt: Set<string>, field: string): Finding[] {\n  return rows\n    .filter(one => one.name && !pointedAt.has(one.name))\n    .map(one => ({ axis, subject: one.name, kind: 'unused' as const, field }))\n}\n\n/**\n * 마스터 전체를 잰다.\n *\n * **순서에 뜻이 없다.** 어느 축부터 보든 같은 답이 나와야 하고, 그래야 이 결과를 두 번 재서\n * 견줄 수 있다.\n */\nexport function checkMaster(snapshot: MasterSnapshot): Finding[] {\n  const locations = nameSet(snapshot.operationalLocations)\n  const operations = nameSet(snapshot.operationDefinitions)\n  const routes = nameSet(snapshot.routeDefinitions)\n  const materials = nameSet(snapshot.materialDefinitions)\n  const specs = nameSet(snapshot.testSpecifications)\n  const personnelClasses = nameSet(snapshot.personnelClasses)\n  const equipmentClasses = nameSet(snapshot.equipmentClasses)\n  const assetClasses = nameSet(snapshot.physicalAssetClasses)\n  const materialClasses = nameSet(snapshot.materialClasses)\n  const stopReasons = nameSet(snapshot.stopReasons)\n\n  const found: Finding[] = [\n    ...checkAxis('person', snapshot.persons, ['personnelClassIds', 'homeLocation'], [\n      { field: 'personnelClassIds', within: personnelClasses },\n      { field: 'homeLocation', within: locations },\n      { field: 'testSpecificationIds', within: specs }\n    ]),\n\n    ...checkAxis('equipment', snapshot.equipment, ['kind', 'homeLocation', 'equipmentClassIds'], [\n      { field: 'equipmentClassIds', within: equipmentClasses },\n      { field: 'homeLocation', within: locations },\n      { field: 'testSpecificationIds', within: specs }\n    ]),\n\n    ...checkAxis('physicalAsset', snapshot.physicalAssets, ['assetClassIds'], [\n      { field: 'assetClassIds', within: assetClasses },\n      { field: 'homeLocation', within: locations },\n      { field: 'testSpecificationIds', within: specs }\n    ]),\n\n    ...checkAxis('materialDefinition', snapshot.materialDefinitions, ['materialClassIds'], [\n      { field: 'materialClassIds', within: materialClasses },\n      { field: 'testSpecificationIds', within: specs }\n    ]),\n\n    /*\n     * 공정의 `resourceType` 은 설비 **종류**를 가리키는 값이라 이름 집합이 없다. 여기서는\n     * 비었는지만 본다 — 없는 것을 있는 척 검사하지 않는다.\n     */\n    ...checkAxis('operationDefinition', snapshot.operationDefinitions, ['intent', 'locationType', 'duration'], []),\n\n    ...checkAxis('routeDefinition', snapshot.routeDefinitions, ['steps'], [\n      { field: 'steps', within: operations }\n    ]),\n\n    ...checkAxis('recipeDefinition', snapshot.recipeDefinitions, ['materialDefinitionName', 'route', 'inputs'], [\n      { field: 'materialDefinitionName', within: materials },\n      { field: 'route', within: routes }\n    ]),\n\n    ...checkAxis('operationalLocation', snapshot.operationalLocations, ['type', 'level'], [\n      { field: 'parentId', within: locations }\n    ]),\n\n    ...checkAxis('stopReason', snapshot.stopReasons, ['status'], [{ field: 'parentName', within: stopReasons }]),\n\n    ...checkAxis('testSpecification', snapshot.testSpecifications, ['criteria'], [])\n  ]\n\n  /*\n   * 제조법의 투입은 한 줄이 여럿을 가리킨다. 위의 검사는 칸 하나를 보므로 여기서 따로 본다.\n   */\n  for (const recipe of snapshot.recipeDefinitions) {\n    for (const part of recipe.inputs ?? []) {\n      if (part?.material && !materials.has(part.material)) {\n        found.push({ axis: 'recipeDefinition', subject: recipe.name, kind: 'dangling', field: 'inputs.material', value: part.material })\n      }\n      if (part?.operation && !operations.has(part.operation)) {\n        found.push({ axis: 'recipeDefinition', subject: recipe.name, kind: 'dangling', field: 'inputs.operation', value: part.operation })\n      }\n    }\n  }\n\n  /*\n   * ── 세워 놓고 아무도 안 든 등급 ─────────────────────────────────────────\n   *\n   * **상속을 타고 센다.** 등급은 등급을 상속하고(`baseIds`), 자격 판정도 그 사슬을 닫아서 본다\n   * (커널의 `classClosure`). 그러니 「아무도 안 든다」도 닫힌 소속으로 물어야 한다.\n   *\n   * 직접 소속만 세면 뿌리 등급이 늘 걸린다. 품목의 유형 등급(완제품 · 반제품 · 원재료)이 그렇다 —\n   * 품목은 성격 등급에 들고 그 등급이 유형을 상속하므로, 직접 소속은 언제나 0이다. 그것을 결함으로\n   * 읽으면 멀쩡한 등급을 지우러 간다.\n   *\n   * 처음에는 품목만 따로 다뤘고 나머지 셋은 직접 소속으로 셌다. 아키텍트 레인이 설비 등급에도\n   * 같은 축이 있다고 알려 주어 넷을 한 규칙으로 모았다 — 축마다 다르게 세면 한쪽만 고쳐지는 날이\n   * 온다. [재봤음] 2026-09-04\n   */\n  const classAxes: [string, Row[], Row[], string][] = [\n    ['personnelClass', snapshot.personnelClasses, snapshot.persons, 'personnelClassIds'],\n    ['equipmentClass', snapshot.equipmentClasses, snapshot.equipment, 'equipmentClassIds'],\n    ['physicalAssetClass', snapshot.physicalAssetClasses, snapshot.physicalAssets, 'assetClassIds'],\n    ['materialClass', snapshot.materialClasses, snapshot.materialDefinitions, 'materialClassIds']\n  ]\n\n  for (const [axis, classes, members, field] of classAxes) {\n    found.push(...checkUnused(axis, classes, closedMembership(classes, members, field), 'members'))\n  }\n\n  /* 아무도 안 가리키는 라우팅·공정. 만들어 놓고 안 쓰는 것은 지워도 되는 것인지 사람이 판단한다. */\n  const routesUsed = new Set(snapshot.recipeDefinitions.map(one => one.route).filter(Boolean))\n  const operationsUsed = new Set([\n    ...snapshot.routeDefinitions.flatMap(one => asList(one.steps)),\n    ...snapshot.recipeDefinitions.flatMap(one => (one.inputs ?? []).map((part: any) => part?.operation).filter(Boolean))\n  ])\n\n  found.push(\n    ...checkUnused('routeDefinition', snapshot.routeDefinitions, routesUsed, 'usedByRecipes'),\n    ...checkUnused('operationDefinition', snapshot.operationDefinitions, operationsUsed, 'usedInRoutes')\n  )\n\n  return found\n}\n\n/**\n * **닫힌 소속** — 소속이 상속을 타고 닿는 등급까지 모은다.\n *\n * 사람이 `welding-robot-6axis` 에 들고 그것이 `welding-equipment` 를 상속하면, 두 등급 다 「누가\n * 들었다」로 센다. 자격 판정이 그 사슬을 닫아서 보므로(커널의 `classClosure`) 여기서도 같게 본다.\n *\n * **고리를 밟으면 멈춘다.** `baseIds` 는 화면에서 손으로 넣을 수 있어 A→B→A 가 생길 수 있다.\n */\nfunction closedMembership(classes: Row[], members: Row[], field: string): Set<string> {\n  const baseOf = new Map(classes.map(one => [one.name, asList(one.baseIds)]))\n  const reached = new Set<string>()\n\n  const walk = (name: string) => {\n    if (!name || reached.has(name)) {\n      return\n    }\n    reached.add(name)\n\n    for (const base of baseOf.get(name) ?? []) {\n      walk(base)\n    }\n  }\n\n  for (const row of members) {\n    for (const name of asList(row[field])) {\n      walk(name)\n    }\n  }\n\n  return reached\n}\n\n/** 여러 줄이 가리키는 이름들을 모은다. */\nfunction collect(rows: Row[], field: string): Set<string> {\n  return new Set(rows.flatMap(one => asList(one[field])))\n}\n\n/**\n * **무엇을 몇 개 봤나.**\n *\n * 어긋남 0건이 「멀쩡하다」인지 「안 돌았다」인지는 이것으로만 갈린다. 본 수를 안 내면 두 답이\n * 같은 글자로 나온다 — 검사기가 스스로를 못 믿게 만드는 가장 흔한 방식이다.\n */\nexport function scannedCounts(snapshot: MasterSnapshot): { axis: string; rows: number }[] {\n  return Object.entries(snapshot)\n    .map(([axis, rows]) => ({ axis, rows: (rows as Row[]).length }))\n    .sort((a, b) => a.axis.localeCompare(b.axis))\n}\n\n/** 축·종류별로 몇 건인지. 사람이 먼저 볼 것을 고르는 데 쓴다. */\nexport function summarize(findings: Finding[]): { axis: string; kind: string; count: number }[] {\n  const tally = new Map<string, number>()\n\n  for (const one of findings) {\n    const key = `${one.axis}\u0000${one.kind}`\n    tally.set(key, (tally.get(key) ?? 0) + 1)\n  }\n\n  return [...tally.entries()]\n    .map(([key, count]) => {\n      const [axis, kind] = key.split('\u0000')\n\n      return { axis, kind, count }\n    })\n    .sort((a, b) => b.count - a.count || a.axis.localeCompare(b.axis))\n}\n\n/**\n * 한 도메인의 마스터를 통째로 읽어 잰다.\n *\n * **상한을 두지 않는다.** 정합성은 「전부 봤나」가 곧 답이라, 일부만 보고 「어긋남 0건」이라고 하면\n * 그 답이 거짓이 된다. 그래서 이것은 목록 화면이 부르는 것이 아니라 **사람이 눌러서 도는 검사**다.\n */\nexport async function readMasterSnapshot(domain: any, getRepository: any, entities: Record<string, any>): Promise<MasterSnapshot> {\n  const all = async (Entity: any, select: string[]) =>\n    (await getRepository(Entity).find({\n      where: { domain: { id: domain.id } } as any,\n      select: ['id', 'name', ...select] as any\n    })) as Row[]\n\n  const [\n    persons, equipment, physicalAssets, materialDefinitions, operationDefinitions,\n    routeDefinitions, recipeDefinitions, operationalLocations, stopReasons, testSpecifications,\n    personnelClasses, equipmentClasses, physicalAssetClasses, materialClasses\n  ] = await Promise.all([\n    all(entities.Person, ['personnelClassIds', 'homeLocation', 'testSpecificationIds']),\n    all(entities.Equipment, ['kind', 'homeLocation', 'equipmentClassIds', 'testSpecificationIds']),\n    all(entities.PhysicalAsset, ['assetClassIds', 'homeLocation', 'testSpecificationIds']),\n    all(entities.MaterialDefinition, ['materialClassIds', 'testSpecificationIds']),\n    all(entities.OperationDefinition, ['intent', 'locationType', 'resourceType', 'duration']),\n    all(entities.RouteDefinition, ['steps']),\n    all(entities.RecipeDefinition, ['materialDefinitionName', 'route', 'inputs']),\n    all(entities.OperationalLocation, ['type', 'level', 'parentId']),\n    all(entities.StopReason, ['status', 'parentName']),\n    all(entities.TestSpecification, ['criteria']),\n    all(entities.PersonnelClass, ['baseIds']),\n    all(entities.EquipmentClass, ['baseIds']),\n    all(entities.PhysicalAssetClass, ['baseIds']),\n    all(entities.MaterialClass, ['baseIds'])\n  ])\n\n  return {\n    persons, equipment, physicalAssets, materialDefinitions, operationDefinitions,\n    routeDefinitions, recipeDefinitions, operationalLocations, stopReasons, testSpecifications,\n    personnelClasses, equipmentClasses, physicalAssetClasses, materialClasses\n  }\n}\n"]}

package/dist-server/service/master-page-query.d.ts

@@ -0,0 +1,33 @@
+import { Domain } from '@things-factory/shell';
+import type { Page, PageRequest } from './master-page';
+/**
+ * 마스터 한 축을 **나눠 읽는다** — 저장소 쪽. 판단은 `master-page` 가 한다.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 등급은 매 쪽에 통째로 싣는다 ───────────────────────────────────────────
+ * 이 축들은 구성원이 자기 **등급을 이름으로 가리킨다.** 등급과 구성원을 따로 나눠 보내면 구성원이
+ * 먼저 도착하고 등급이 나중에 오는 순간이 생기고, 그 순간 받는 쪽은 **없는 등급을 가리키는 구성원**을
+ * 갖는다. 원래 이 조회들이 「자르지 않는다」고 적어 둔 이유가 그것이다.
+ *
+ * 그래서 **구성원만 나누고 등급은 매 쪽에 전부 싣는다.** 등급은 수십 단위라 실어도 크지 않고, 그러면
+ * 어느 쪽을 먼저 받아도 가리키는 곳이 항상 있다.
+ *
+ * ── 이름 다음부터 읽는다 ───────────────────────────────────────────────────
+ * `skip` 은 규모에서 못 쓴다 — 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로 정렬해 내므로
+ * **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+/**
+ * 한 축을 한 쪽만큼 읽는다.
+ *
+ * 이름 칸을 받는 이유: 축마다 다르다(`name` · `operationKey` …). 여기서 알아보려 하면 축이 늘 때마다
+ * 이 함수를 고쳐야 한다.
+ */
+export declare function pullPage<T>(entity: any, domain: Domain, request: PageRequest, nameColumn?: keyof T & string): Promise<Page<T>>;
+/**
+ * **통째로 달라고 했는데 너무 크면 던진다.**
+ *
+ * 자르고 넘어가지 않는다 — 받는 쪽은 그것이 전부인 줄 알고 트윈을 세우고, 없는 품목이 화면에서 그냥
+ * 존재하지 않게 된다. 오류가 안 난다. 그래서 **틀린 답 대신 오류**를 준다.
+ */
+export declare function refuseIfTooLarge(axis: string, request: PageRequest, page: Page<unknown>): void;

package/dist-server/service/master-page-query.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pullPage = pullPage;
+exports.refuseIfTooLarge = refuseIfTooLarge;
+const typeorm_1 = require("typeorm");
+const shell_1 = require("@things-factory/shell");
+const master_page_1 = require("./master-page");
+/**
+ * 마스터 한 축을 **나눠 읽는다** — 저장소 쪽. 판단은 `master-page` 가 한다.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 등급은 매 쪽에 통째로 싣는다 ───────────────────────────────────────────
+ * 이 축들은 구성원이 자기 **등급을 이름으로 가리킨다.** 등급과 구성원을 따로 나눠 보내면 구성원이
+ * 먼저 도착하고 등급이 나중에 오는 순간이 생기고, 그 순간 받는 쪽은 **없는 등급을 가리키는 구성원**을
+ * 갖는다. 원래 이 조회들이 「자르지 않는다」고 적어 둔 이유가 그것이다.
+ *
+ * 그래서 **구성원만 나누고 등급은 매 쪽에 전부 싣는다.** 등급은 수십 단위라 실어도 크지 않고, 그러면
+ * 어느 쪽을 먼저 받아도 가리키는 곳이 항상 있다.
+ *
+ * ── 이름 다음부터 읽는다 ───────────────────────────────────────────────────
+ * `skip` 은 규모에서 못 쓴다 — 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로 정렬해 내므로
+ * **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+/**
+ * 한 축을 한 쪽만큼 읽는다.
+ *
+ * 이름 칸을 받는 이유: 축마다 다르다(`name` · `operationKey` …). 여기서 알아보려 하면 축이 늘 때마다
+ * 이 함수를 고쳐야 한다.
+ */
+async function pullPage(entity, domain, request, nameColumn = 'name') {
+    const where = { domain: { id: domain.id } };
+    if (request.after) {
+        where[nameColumn] = (0, typeorm_1.MoreThan)(request.after);
+    }
+    const read = (await (0, shell_1.getRepository)(entity).find({
+        where,
+        order: { [nameColumn]: 'ASC' },
+        take: (0, master_page_1.takeFor)(request)
+    }));
+    return (0, master_page_1.pageOf)(read, request, row => String(row[nameColumn]));
+}
+/**
+ * **통째로 달라고 했는데 너무 크면 던진다.**
+ *
+ * 자르고 넘어가지 않는다 — 받는 쪽은 그것이 전부인 줄 알고 트윈을 세우고, 없는 품목이 화면에서 그냥
+ * 존재하지 않게 된다. 오류가 안 난다. 그래서 **틀린 답 대신 오류**를 준다.
+ */
+function refuseIfTooLarge(axis, request, page) {
+    const problem = (0, master_page_1.tooLargeToPull)(axis, request, page);
+    if (problem) {
+        throw new Error(problem);
+    }
+}
+//# sourceMappingURL=master-page-query.js.map

package/dist-server/service/master-page-query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-page-query.js","sourceRoot":"","sources":["../../server/service/master-page-query.ts"],"names":[],"mappings":";;AA+BA,4BAmBC;AAQD,4CAMC;AAhED,qCAAkC;AAElC,iDAA6D;AAE7D,+CAA+D;AAG/D;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;GAKG;AACI,KAAK,UAAU,QAAQ,CAC5B,MAAW,EACX,MAAc,EACd,OAAoB,EACpB,aAA+B,MAAa;IAE5C,MAAM,KAAK,GAA4B,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,EAAE,CAAA;IAEpE,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;QAClB,KAAK,CAAC,UAAU,CAAC,GAAG,IAAA,kBAAQ,EAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IAC7C,CAAC;IAED,MAAM,IAAI,GAAG,CAAC,MAAM,IAAA,qBAAa,EAAC,MAAM,CAAC,CAAC,IAAI,CAAC;QAC7C,KAAK;QACL,KAAK,EAAE,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE;QAC9B,IAAI,EAAE,IAAA,qBAAO,EAAC,OAAO,CAAC;KACvB,CAAC,CAAQ,CAAA;IAEV,OAAO,IAAA,oBAAM,EAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC,MAAM,CAAE,GAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAA;AACvE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,IAAY,EAAE,OAAoB,EAAE,IAAmB;IACtF,MAAM,OAAO,GAAG,IAAA,4BAAc,EAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,CAAA;IAEnD,IAAI,OAAO,EAAE,CAAC;QACZ,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAA;IAC1B,CAAC;AACH,CAAC","sourcesContent":["import { MoreThan } from 'typeorm'\n\nimport { Domain, getRepository } from '@things-factory/shell'\n\nimport { pageOf, takeFor, tooLargeToPull } from './master-page'\nimport type { Page, PageRequest } from './master-page'\n\n/**\n * 마스터 한 축을 **나눠 읽는다** — 저장소 쪽. 판단은 `master-page` 가 한다.\n *\n * ═══════════════════════════════════════════════════════════════════════════\n * ── 등급은 매 쪽에 통째로 싣는다 ───────────────────────────────────────────\n * 이 축들은 구성원이 자기 **등급을 이름으로 가리킨다.** 등급과 구성원을 따로 나눠 보내면 구성원이\n * 먼저 도착하고 등급이 나중에 오는 순간이 생기고, 그 순간 받는 쪽은 **없는 등급을 가리키는 구성원**을\n * 갖는다. 원래 이 조회들이 「자르지 않는다」고 적어 둔 이유가 그것이다.\n *\n * 그래서 **구성원만 나누고 등급은 매 쪽에 전부 싣는다.** 등급은 수십 단위라 실어도 크지 않고, 그러면\n * 어느 쪽을 먼저 받아도 가리키는 곳이 항상 있다.\n *\n * ── 이름 다음부터 읽는다 ───────────────────────────────────────────────────\n * `skip` 은 규모에서 못 쓴다 — 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로 정렬해 내므로\n * **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.\n * ═══════════════════════════════════════════════════════════════════════════\n */\n\n/**\n * 한 축을 한 쪽만큼 읽는다.\n *\n * 이름 칸을 받는 이유: 축마다 다르다(`name` · `operationKey` …). 여기서 알아보려 하면 축이 늘 때마다\n * 이 함수를 고쳐야 한다.\n */\nexport async function pullPage<T>(\n  entity: any,\n  domain: Domain,\n  request: PageRequest,\n  nameColumn: keyof T & string = 'name' as any\n): Promise<Page<T>> {\n  const where: Record<string, unknown> = { domain: { id: domain.id } }\n\n  if (request.after) {\n    where[nameColumn] = MoreThan(request.after)\n  }\n\n  const read = (await getRepository(entity).find({\n    where,\n    order: { [nameColumn]: 'ASC' },\n    take: takeFor(request)\n  })) as T[]\n\n  return pageOf(read, request, row => String((row as any)[nameColumn]))\n}\n\n/**\n * **통째로 달라고 했는데 너무 크면 던진다.**\n *\n * 자르고 넘어가지 않는다 — 받는 쪽은 그것이 전부인 줄 알고 트윈을 세우고, 없는 품목이 화면에서 그냥\n * 존재하지 않게 된다. 오류가 안 난다. 그래서 **틀린 답 대신 오류**를 준다.\n */\nexport function refuseIfTooLarge(axis: string, request: PageRequest, page: Page<unknown>): void {\n  const problem = tooLargeToPull(axis, request, page)\n\n  if (problem) {\n    throw new Error(problem)\n  }\n}\n"]}

package/dist-server/service/master-page.d.ts

@@ -0,0 +1,85 @@
+/**
+ * **마스터를 나눠 내는 규칙** — 순수 판단.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 무엇이 문제였나 ────────────────────────────────────────────────────────
+ * 트윈이 당겨 가는 마스터 조회 여덟 축이 **전부 전량 조회**였다. 도메인 조건 하나만 걸고 그 축의 모든
+ * 행을 읽어 JSON 한 덩어리로 낸다.
+ *
+ * 재봤다: 품목 100만에서 **2,219ms · 49MB**. 지금 미라텍은 자재 106개라 안 아프지만, 이 제품의 규모
+ * 기준은 엔티티 10만 · 품목 100만이다. 그 규모에서 이 조회는 서지 않는다.
+ *
+ * ── 왜 「조용히 자르기」가 아니라 「거절」인가 ──────────────────────────────
+ * 한계를 두고 **말없이 앞부분만 주는 것이 제일 나쁘다.** 받는 쪽은 그것이 전부인 줄 알고 트윈을
+ * 세우고, 없는 설비·없는 품목이 화면에서 그냥 **존재하지 않게** 된다. 오류가 안 난다.
+ *
+ * 오늘 하루 종일 잡은 부류가 그것이라, 여기서는 그렇게 하지 않는다.
+ *
+ *   나눠 달라고 하면(`limit`)   그만큼 주고 **더 있는지 말한다**(`hasMore`)
+ *   통째로 달라고 했는데 크면    **거절하고 나눠 받으라고 말한다**
+ *   통째로 달라고 했는데 작으면   그냥 준다 — 대부분의 현장이 여기다
+ *
+ * 그래서 작은 공장은 지금 그대로 돌고, 큰 공장은 **틀린 답 대신 오류**를 받는다.
+ *
+ * ── 왜 이름으로 이어 받나 ──────────────────────────────────────────────────
+ * `offset` 은 규모에서 못 쓴다 — 뒤로 갈수록 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로
+ * 정렬해 내므로(`order: { name: 'ASC' }`), **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.
+ *
+ * 이름이 유일하다는 것에 기댄다. 도메인 안에서 마스터 이름은 유일하다(그 이름으로 실적·사실이 자원을
+ * 가리킨다 — 유일하지 않으면 그것부터 깨진다).
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+/**
+ * 한 번에 낼 수 있는 **최대**. 이보다 크게 달라고 해도 이만큼만 낸다.
+ *
+ * ⚠ **이것은 안전장치이지 권하는 쪽 크기가 아니다.** 받는 쪽이 이 수에 붙여 두면, 우리가 한도를
+ * 내리는 날 그쪽은 **그날부터** 못 읽는다. 권하는 크기는 `SUGGESTED_PAGE` 다.
+ *
+ * 인티그레이션이 붙이면서 스스로 이 구별을 하고 2,000 을 골랐다(2026-09-05) — 「그 수는 거절하는
+ * 자리이지 권하는 크기가 아니다」. 맞는 판단이고, 여기 적혀 있지 않아서 스스로 알아낸 것이라 적는다.
+ */
+export declare const MAX_PAGE = 5000;
+/**
+ * 권하는 쪽 크기.
+ *
+ * [재봤음] 품목 100만이 전량 49MB 였으니 2,000이면 한 쪽이 100KB 안팎이다. 한 쪽에 1.4ms 이고
+ * 이어받기는 0.1ms 라, 쪽을 더 키워 얻을 것이 없다.
+ */
+export declare const SUGGESTED_PAGE = 2000;
+/** `limit` 을 안 주고 나눠 받지도 않을 때, 통째로 내주는 한도. 넘으면 거절한다. */
+export declare const WHOLE_LIMIT = 5000;
+/** 나눠 달라고 했는데 몇 개인지는 안 말했을 때. */
+export declare const DEFAULT_PAGE = 1000;
+export interface PageRequest {
+    /** 이 이름 **다음부터**. 앞 페이지의 `next` 를 그대로 준다. */
+    after?: string;
+    /** 몇 개까지. 없으면 통째로 달라는 뜻이다. */
+    limit?: number;
+}
+/**
+ * 실제로 몇 개를 읽을 것인가.
+ *
+ * **하나를 더 읽는다.** 더 있는지 알려면 세거나(`COUNT`) 한 개 더 읽어야 하는데, 세는 것은 같은 조건을
+ * 두 번 훑는 것이라 규모에서 두 배가 된다.
+ */
+export declare function takeFor(request: PageRequest): number;
+export interface Page<T> {
+    rows: T[];
+    /** 더 있나. **이 값을 안 보고 쓰면 조용히 잘린 자료를 쓰게 된다.** */
+    hasMore: boolean;
+    /** 이어 받을 자리 — 다음 요청의 `after`. 더 없으면 없다. */
+    next?: string;
+}
+/**
+ * 하나 더 읽어 온 결과를 페이지로 만든다.
+ *
+ * `nameOf` 를 받는 이유: 축마다 이름 칸이 다르다(`name` · `operationKey` …). 그 차이를 여기서 알아보려
+ * 하면 축이 늘 때마다 이 함수를 고쳐야 한다.
+ */
+export declare function pageOf<T>(read: readonly T[], request: PageRequest, nameOf: (row: T) => string): Page<T>;
+/**
+ * **통째로 달라고 했는데 너무 크다** — 낼 수 없는 이유를 사람 말로.
+ *
+ * 자르지 않는다. 자르면 받는 쪽은 그것이 전부인 줄 안다.
+ */
+export declare function tooLargeToPull(axis: string, request: PageRequest, page: Page<unknown>): string | undefined;

package/dist-server/service/master-page.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * **마스터를 나눠 내는 규칙** — 순수 판단.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 무엇이 문제였나 ────────────────────────────────────────────────────────
+ * 트윈이 당겨 가는 마스터 조회 여덟 축이 **전부 전량 조회**였다. 도메인 조건 하나만 걸고 그 축의 모든
+ * 행을 읽어 JSON 한 덩어리로 낸다.
+ *
+ * 재봤다: 품목 100만에서 **2,219ms · 49MB**. 지금 미라텍은 자재 106개라 안 아프지만, 이 제품의 규모
+ * 기준은 엔티티 10만 · 품목 100만이다. 그 규모에서 이 조회는 서지 않는다.
+ *
+ * ── 왜 「조용히 자르기」가 아니라 「거절」인가 ──────────────────────────────
+ * 한계를 두고 **말없이 앞부분만 주는 것이 제일 나쁘다.** 받는 쪽은 그것이 전부인 줄 알고 트윈을
+ * 세우고, 없는 설비·없는 품목이 화면에서 그냥 **존재하지 않게** 된다. 오류가 안 난다.
+ *
+ * 오늘 하루 종일 잡은 부류가 그것이라, 여기서는 그렇게 하지 않는다.
+ *
+ *   나눠 달라고 하면(`limit`)   그만큼 주고 **더 있는지 말한다**(`hasMore`)
+ *   통째로 달라고 했는데 크면    **거절하고 나눠 받으라고 말한다**
+ *   통째로 달라고 했는데 작으면   그냥 준다 — 대부분의 현장이 여기다
+ *
+ * 그래서 작은 공장은 지금 그대로 돌고, 큰 공장은 **틀린 답 대신 오류**를 받는다.
+ *
+ * ── 왜 이름으로 이어 받나 ──────────────────────────────────────────────────
+ * `offset` 은 규모에서 못 쓴다 — 뒤로 갈수록 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로
+ * 정렬해 내므로(`order: { name: 'ASC' }`), **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.
+ *
+ * 이름이 유일하다는 것에 기댄다. 도메인 안에서 마스터 이름은 유일하다(그 이름으로 실적·사실이 자원을
+ * 가리킨다 — 유일하지 않으면 그것부터 깨진다).
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PAGE = exports.WHOLE_LIMIT = exports.SUGGESTED_PAGE = exports.MAX_PAGE = void 0;
+exports.takeFor = takeFor;
+exports.pageOf = pageOf;
+exports.tooLargeToPull = tooLargeToPull;
+/**
+ * 한 번에 낼 수 있는 **최대**. 이보다 크게 달라고 해도 이만큼만 낸다.
+ *
+ * ⚠ **이것은 안전장치이지 권하는 쪽 크기가 아니다.** 받는 쪽이 이 수에 붙여 두면, 우리가 한도를
+ * 내리는 날 그쪽은 **그날부터** 못 읽는다. 권하는 크기는 `SUGGESTED_PAGE` 다.
+ *
+ * 인티그레이션이 붙이면서 스스로 이 구별을 하고 2,000 을 골랐다(2026-09-05) — 「그 수는 거절하는
+ * 자리이지 권하는 크기가 아니다」. 맞는 판단이고, 여기 적혀 있지 않아서 스스로 알아낸 것이라 적는다.
+ */
+exports.MAX_PAGE = 5_000;
+/**
+ * 권하는 쪽 크기.
+ *
+ * [재봤음] 품목 100만이 전량 49MB 였으니 2,000이면 한 쪽이 100KB 안팎이다. 한 쪽에 1.4ms 이고
+ * 이어받기는 0.1ms 라, 쪽을 더 키워 얻을 것이 없다.
+ */
+exports.SUGGESTED_PAGE = 2_000;
+/** `limit` 을 안 주고 나눠 받지도 않을 때, 통째로 내주는 한도. 넘으면 거절한다. */
+exports.WHOLE_LIMIT = 5_000;
+/** 나눠 달라고 했는데 몇 개인지는 안 말했을 때. */
+exports.DEFAULT_PAGE = 1_000;
+/**
+ * 실제로 몇 개를 읽을 것인가.
+ *
+ * **하나를 더 읽는다.** 더 있는지 알려면 세거나(`COUNT`) 한 개 더 읽어야 하는데, 세는 것은 같은 조건을
+ * 두 번 훑는 것이라 규모에서 두 배가 된다.
+ */
+function takeFor(request) {
+    if (request.limit === undefined) {
+        /* 통째로 달라는 요청이다. 한도를 넘는지 보려면 한도+1 을 읽어 봐야 한다. */
+        return exports.WHOLE_LIMIT + 1;
+    }
+    /* 0 이나 음수를 「전부」로 읽지 않는다 — 그렇게 읽으면 실수 하나가 전량 조회가 된다. */
+    const asked = Math.floor(request.limit);
+    const bounded = Number.isFinite(asked) ? Math.min(Math.max(asked, 1), exports.MAX_PAGE) : exports.DEFAULT_PAGE;
+    return bounded + 1;
+}
+/**
+ * 하나 더 읽어 온 결과를 페이지로 만든다.
+ *
+ * `nameOf` 를 받는 이유: 축마다 이름 칸이 다르다(`name` · `operationKey` …). 그 차이를 여기서 알아보려
+ * 하면 축이 늘 때마다 이 함수를 고쳐야 한다.
+ */
+function pageOf(read, request, nameOf) {
+    const size = takeFor(request) - 1;
+    const hasMore = read.length > size;
+    const rows = hasMore ? read.slice(0, size) : [...read];
+    return {
+        rows,
+        hasMore,
+        ...(hasMore && rows.length ? { next: nameOf(rows[rows.length - 1]) } : {})
+    };
+}
+/**
+ * **통째로 달라고 했는데 너무 크다** — 낼 수 없는 이유를 사람 말로.
+ *
+ * 자르지 않는다. 자르면 받는 쪽은 그것이 전부인 줄 안다.
+ */
+function tooLargeToPull(axis, request, page) {
+    if (request.limit !== undefined || !page.hasMore) {
+        return undefined;
+    }
+    return (`${axis} 축이 한 번에 낼 수 있는 ${exports.WHOLE_LIMIT}건을 넘습니다. ` +
+        `limit 과 after 로 나눠 받으십시오 — ${exports.SUGGESTED_PAGE}건쯤이 알맞고(최대 ${exports.MAX_PAGE}건), ` +
+        '응답의 hasMore 가 거짓이 될 때까지 next 를 after 로 넘기면 됩니다.');
+}
+//# sourceMappingURL=master-page.js.map

package/dist-server/service/master-page.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"master-page.js","sourceRoot":"","sources":["../../server/service/master-page.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;;;AAwCH,0BAWC;AAgBD,wBAUC;AAOD,wCAUC;AA5FD;;;;;;;;GAQG;AACU,QAAA,QAAQ,GAAG,KAAK,CAAA;AAE7B;;;;;GAKG;AACU,QAAA,cAAc,GAAG,KAAK,CAAA;AAEnC,wDAAwD;AAC3C,QAAA,WAAW,GAAG,KAAK,CAAA;AAEhC,iCAAiC;AACpB,QAAA,YAAY,GAAG,KAAK,CAAA;AASjC;;;;;GAKG;AACH,SAAgB,OAAO,CAAC,OAAoB;IAC1C,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAChC,gDAAgD;QAChD,OAAO,mBAAW,GAAG,CAAC,CAAA;IACxB,CAAC;IAED,uDAAuD;IACvD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;IACvC,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,gBAAQ,CAAC,CAAC,CAAC,CAAC,oBAAY,CAAA;IAE9F,OAAO,OAAO,GAAG,CAAC,CAAA;AACpB,CAAC;AAUD;;;;;GAKG;AACH,SAAgB,MAAM,CAAI,IAAkB,EAAE,OAAoB,EAAE,MAA0B;IAC5F,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;IACjC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;IAClC,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAA;IAEtD,OAAO;QACL,IAAI;QACJ,OAAO;QACP,GAAG,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC3E,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAC,IAAY,EAAE,OAAoB,EAAE,IAAmB;IACpF,IAAI,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACjD,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,OAAO,CACL,GAAG,IAAI,mBAAmB,mBAAW,WAAW;QAChD,8BAA8B,sBAAc,cAAc,gBAAQ,MAAM;QACxE,iDAAiD,CAClD,CAAA;AACH,CAAC","sourcesContent":["/**\n * **마스터를 나눠 내는 규칙** — 순수 판단.\n *\n * ═══════════════════════════════════════════════════════════════════════════\n * ── 무엇이 문제였나 ────────────────────────────────────────────────────────\n * 트윈이 당겨 가는 마스터 조회 여덟 축이 **전부 전량 조회**였다. 도메인 조건 하나만 걸고 그 축의 모든\n * 행을 읽어 JSON 한 덩어리로 낸다.\n *\n * 재봤다: 품목 100만에서 **2,219ms · 49MB**. 지금 미라텍은 자재 106개라 안 아프지만, 이 제품의 규모\n * 기준은 엔티티 10만 · 품목 100만이다. 그 규모에서 이 조회는 서지 않는다.\n *\n * ── 왜 「조용히 자르기」가 아니라 「거절」인가 ──────────────────────────────\n * 한계를 두고 **말없이 앞부분만 주는 것이 제일 나쁘다.** 받는 쪽은 그것이 전부인 줄 알고 트윈을\n * 세우고, 없는 설비·없는 품목이 화면에서 그냥 **존재하지 않게** 된다. 오류가 안 난다.\n *\n * 오늘 하루 종일 잡은 부류가 그것이라, 여기서는 그렇게 하지 않는다.\n *\n *   나눠 달라고 하면(`limit`)   그만큼 주고 **더 있는지 말한다**(`hasMore`)\n *   통째로 달라고 했는데 크면    **거절하고 나눠 받으라고 말한다**\n *   통째로 달라고 했는데 작으면   그냥 준다 — 대부분의 현장이 여기다\n *\n * 그래서 작은 공장은 지금 그대로 돌고, 큰 공장은 **틀린 답 대신 오류**를 받는다.\n *\n * ── 왜 이름으로 이어 받나 ──────────────────────────────────────────────────\n * `offset` 은 규모에서 못 쓴다 — 뒤로 갈수록 건너뛴 만큼을 매번 다시 읽는다. 이 축들은 이미 이름으로\n * 정렬해 내므로(`order: { name: 'ASC' }`), **마지막 이름 다음부터** 읽으면 건너뛸 것이 없다.\n *\n * 이름이 유일하다는 것에 기댄다. 도메인 안에서 마스터 이름은 유일하다(그 이름으로 실적·사실이 자원을\n * 가리킨다 — 유일하지 않으면 그것부터 깨진다).\n * ═══════════════════════════════════════════════════════════════════════════\n */\n\n/**\n * 한 번에 낼 수 있는 **최대**. 이보다 크게 달라고 해도 이만큼만 낸다.\n *\n * ⚠ **이것은 안전장치이지 권하는 쪽 크기가 아니다.** 받는 쪽이 이 수에 붙여 두면, 우리가 한도를\n * 내리는 날 그쪽은 **그날부터** 못 읽는다. 권하는 크기는 `SUGGESTED_PAGE` 다.\n *\n * 인티그레이션이 붙이면서 스스로 이 구별을 하고 2,000 을 골랐다(2026-09-05) — 「그 수는 거절하는\n * 자리이지 권하는 크기가 아니다」. 맞는 판단이고, 여기 적혀 있지 않아서 스스로 알아낸 것이라 적는다.\n */\nexport const MAX_PAGE = 5_000\n\n/**\n * 권하는 쪽 크기.\n *\n * [재봤음] 품목 100만이 전량 49MB 였으니 2,000이면 한 쪽이 100KB 안팎이다. 한 쪽에 1.4ms 이고\n * 이어받기는 0.1ms 라, 쪽을 더 키워 얻을 것이 없다.\n */\nexport const SUGGESTED_PAGE = 2_000\n\n/** `limit` 을 안 주고 나눠 받지도 않을 때, 통째로 내주는 한도. 넘으면 거절한다. */\nexport const WHOLE_LIMIT = 5_000\n\n/** 나눠 달라고 했는데 몇 개인지는 안 말했을 때. */\nexport const DEFAULT_PAGE = 1_000\n\nexport interface PageRequest {\n  /** 이 이름 **다음부터**. 앞 페이지의 `next` 를 그대로 준다. */\n  after?: string\n  /** 몇 개까지. 없으면 통째로 달라는 뜻이다. */\n  limit?: number\n}\n\n/**\n * 실제로 몇 개를 읽을 것인가.\n *\n * **하나를 더 읽는다.** 더 있는지 알려면 세거나(`COUNT`) 한 개 더 읽어야 하는데, 세는 것은 같은 조건을\n * 두 번 훑는 것이라 규모에서 두 배가 된다.\n */\nexport function takeFor(request: PageRequest): number {\n  if (request.limit === undefined) {\n    /* 통째로 달라는 요청이다. 한도를 넘는지 보려면 한도+1 을 읽어 봐야 한다. */\n    return WHOLE_LIMIT + 1\n  }\n\n  /* 0 이나 음수를 「전부」로 읽지 않는다 — 그렇게 읽으면 실수 하나가 전량 조회가 된다. */\n  const asked = Math.floor(request.limit)\n  const bounded = Number.isFinite(asked) ? Math.min(Math.max(asked, 1), MAX_PAGE) : DEFAULT_PAGE\n\n  return bounded + 1\n}\n\nexport interface Page<T> {\n  rows: T[]\n  /** 더 있나. **이 값을 안 보고 쓰면 조용히 잘린 자료를 쓰게 된다.** */\n  hasMore: boolean\n  /** 이어 받을 자리 — 다음 요청의 `after`. 더 없으면 없다. */\n  next?: string\n}\n\n/**\n * 하나 더 읽어 온 결과를 페이지로 만든다.\n *\n * `nameOf` 를 받는 이유: 축마다 이름 칸이 다르다(`name` · `operationKey` …). 그 차이를 여기서 알아보려\n * 하면 축이 늘 때마다 이 함수를 고쳐야 한다.\n */\nexport function pageOf<T>(read: readonly T[], request: PageRequest, nameOf: (row: T) => string): Page<T> {\n  const size = takeFor(request) - 1\n  const hasMore = read.length > size\n  const rows = hasMore ? read.slice(0, size) : [...read]\n\n  return {\n    rows,\n    hasMore,\n    ...(hasMore && rows.length ? { next: nameOf(rows[rows.length - 1]) } : {})\n  }\n}\n\n/**\n * **통째로 달라고 했는데 너무 크다** — 낼 수 없는 이유를 사람 말로.\n *\n * 자르지 않는다. 자르면 받는 쪽은 그것이 전부인 줄 안다.\n */\nexport function tooLargeToPull(axis: string, request: PageRequest, page: Page<unknown>): string | undefined {\n  if (request.limit !== undefined || !page.hasMore) {\n    return undefined\n  }\n\n  return (\n    `${axis} 축이 한 번에 낼 수 있는 ${WHOLE_LIMIT}건을 넘습니다. ` +\n    `limit 과 after 로 나눠 받으십시오 — ${SUGGESTED_PAGE}건쯤이 알맞고(최대 ${MAX_PAGE}건), ` +\n    '응답의 hasMore 가 거짓이 될 때까지 next 를 after 로 넘기면 됩니다.'\n  )\n}\n"]}