@things-factory/station 10.1.33

package/dist-server/service/station/screen-model-digest.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 화면 도안 한 판의 **지문** — 서명이 어느 판에 걸린 것인지 가리는 값.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 왜 필요한가 ───────────────────────────────────────────────────────────
+ * 통제 문서는 **판마다** 승인받는다(ISO 9001 7.5.3). 그런데 서명이 화면(`boardId`)에만 걸려 있으면
+ * v1 을 승인한 서명 위로 **v2 가 그대로 나간다** — 통제가 이름만 남는 자리다.
+ *
+ * 번호로는 못 묶는다. `Board.version` 은 발행할 때 정해지고, 상신하는 시점에는 그 번호가 없다.
+ * 그래서 **그때 도안 자체**를 굳힌다 — `shownAtSigning` 이 결재자에게 보인 문장을 굳히는 것과 같다.
+ *
+ * ── 정규화가 이 값의 전부다 ───────────────────────────────────────────────
+ * 키 순서만 달라져도 지문이 바뀌면 **저장할 때마다 재결재**가 되고, 관문은 곧 소음이 되어 사람이
+ * 끄게 된다. 그래서 키를 정렬해 직렬화한 뒤 해시한다.
+ *
+ * **배열 순서는 안 건드린다.** 도안에서 순서는 뜻이다 — 겹치는 순서가 바뀌면 작업자가 보는 것이
+ * 달라진다. 정렬하면 그 변화가 지문에서 사라진다.
+ *
+ * ── 한 자리에서만 만든다 ─────────────────────────────────────────────────
+ * 상신하는 쪽과 발행 관문이 **같은 함수**를 부른다. 두 벌로 두면 한쪽이 정규화를 조금 다르게 하는 날
+ * 모든 서명이 낡은 것으로 읽히고, 아무도 이유를 모른다.
+ *
+ * ── 빼는 칸: **작업자가 화면에서 읽는 것이 아닌 칸** ──────────────────────
+ * 도안 안에 저장할 때마다(또는 한 번) 바뀌는 칸이 있으면 이 값이 달라지고, **내용이 안 바뀐 화면의
+ * 서명이 낡는다.** 기준은 하나다 — 그 칸이 작업자가 화면에서 읽는 것을 바꾸는가.
+ *
+ * ```
+ * threed                 뺀다   2D/3D 토글의 보기 상태. 3D 로 보다가 저장하면 읽는 것은 그대로인데 지문이 바뀐다
+ * refid                  뺀다   things-scene 이 없을 때 한 번 매겨 저장하는 식별 색인
+ *                               (RootContainer.addRefidIndex → set('refid'); 있으면 그대로 둔다)
+ *                               세션마다 바뀌진 않지만 **저작면 도안이 편집기를 처음 지날 때** 붙어
+ *                               지문이 한 번 바뀐다. 부품마다 붙으므로 **재귀로** 뺀다
+ * stationScenario        뺀다   어느 시나리오가 만들었나 — **출처**다. 'rework' 'packing' 같은 값이고
+ *                               작업자는 이것을 안 읽는다(실측: spec 붙은 화면 11개에 있다)
+ * stationScenarioVersion 뺀다   그 출처의 판. 지금 전부 1이고, **시드를 다시 돌려 2가 되면 그려진 것은
+ *                               하나도 안 바뀌는데 서명이 전부 낡는다**(실측: 10개)
+ * type · view · counts   남긴다  구조 · 묶음 타일 종류 · 양품/불량 — 작업자가 읽거나 만지는 내용이다
+ * removable              남긴다  줄을 뺄 수 있나 — 작업자가 만지는 것이다
+ * ```
+ *
+ * **값어치로 예외를 두지 않는다.** 「이건 중요하니까 세자」가 한 번 들어오면 기준이 사라진다.
+ *
+ * ⚠ 이름으로 빼므로 **부품 자료 안에 같은 이름의 칸이 있으면 그것도 빠진다.** 지금 도안에는 없고,
+ * 그런 칸이 생기면 그때는 경로로 빼는 수밖에 없다.
+ *
+ * [합의했다] ADR-0047 ④ — Shop Floor 가 저장된 도안 둘(저작면 것 · 편집기를 지난 것)을 견줘 찾았다.
+ *
+ * ── 글자로 와도 받는다. **그것이 실제 경로다** ────────────────────────────
+ * `Board.model` 은 **문자열 칸**이다(text). 그래서 상신하는 쪽이 읽어 넘기는 값도 글자이고, 그것을
+ * 그대로 해시하면 **정규화가 한 번도 안 돈다** — 같은 도안이라도 저장된 글자의 키 순서나 들여쓰기가
+ * 달라지면 지문이 달라지고, 그 순간 모든 서명이 낡는다. 막으려고 만든 결함을 막는 코드가 그대로
+ * 만들어 내는 자리였다(2026-09-16에 실제로 그랬다).
+ *
+ * 그래서 글자면 **먼저 읽어서** 정규화한다. 못 읽는 글자는 지어내지 않고 글자 그대로 해시한다 —
+ * 여기서 던지면 발행 관문이 그 화면에서 멈춘다.
+ *
+ * [합의했다] operato-application/adr/ADR-0047.md ④
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+export declare function screenModelDigest(model: unknown): string;

package/dist-server/service/station/screen-model-digest.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.screenModelDigest = screenModelDigest;
+const node_crypto_1 = require("node:crypto");
+/**
+ * 화면 도안 한 판의 **지문** — 서명이 어느 판에 걸린 것인지 가리는 값.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ── 왜 필요한가 ───────────────────────────────────────────────────────────
+ * 통제 문서는 **판마다** 승인받는다(ISO 9001 7.5.3). 그런데 서명이 화면(`boardId`)에만 걸려 있으면
+ * v1 을 승인한 서명 위로 **v2 가 그대로 나간다** — 통제가 이름만 남는 자리다.
+ *
+ * 번호로는 못 묶는다. `Board.version` 은 발행할 때 정해지고, 상신하는 시점에는 그 번호가 없다.
+ * 그래서 **그때 도안 자체**를 굳힌다 — `shownAtSigning` 이 결재자에게 보인 문장을 굳히는 것과 같다.
+ *
+ * ── 정규화가 이 값의 전부다 ───────────────────────────────────────────────
+ * 키 순서만 달라져도 지문이 바뀌면 **저장할 때마다 재결재**가 되고, 관문은 곧 소음이 되어 사람이
+ * 끄게 된다. 그래서 키를 정렬해 직렬화한 뒤 해시한다.
+ *
+ * **배열 순서는 안 건드린다.** 도안에서 순서는 뜻이다 — 겹치는 순서가 바뀌면 작업자가 보는 것이
+ * 달라진다. 정렬하면 그 변화가 지문에서 사라진다.
+ *
+ * ── 한 자리에서만 만든다 ─────────────────────────────────────────────────
+ * 상신하는 쪽과 발행 관문이 **같은 함수**를 부른다. 두 벌로 두면 한쪽이 정규화를 조금 다르게 하는 날
+ * 모든 서명이 낡은 것으로 읽히고, 아무도 이유를 모른다.
+ *
+ * ── 빼는 칸: **작업자가 화면에서 읽는 것이 아닌 칸** ──────────────────────
+ * 도안 안에 저장할 때마다(또는 한 번) 바뀌는 칸이 있으면 이 값이 달라지고, **내용이 안 바뀐 화면의
+ * 서명이 낡는다.** 기준은 하나다 — 그 칸이 작업자가 화면에서 읽는 것을 바꾸는가.
+ *
+ * ```
+ * threed                 뺀다   2D/3D 토글의 보기 상태. 3D 로 보다가 저장하면 읽는 것은 그대로인데 지문이 바뀐다
+ * refid                  뺀다   things-scene 이 없을 때 한 번 매겨 저장하는 식별 색인
+ *                               (RootContainer.addRefidIndex → set('refid'); 있으면 그대로 둔다)
+ *                               세션마다 바뀌진 않지만 **저작면 도안이 편집기를 처음 지날 때** 붙어
+ *                               지문이 한 번 바뀐다. 부품마다 붙으므로 **재귀로** 뺀다
+ * stationScenario        뺀다   어느 시나리오가 만들었나 — **출처**다. 'rework' 'packing' 같은 값이고
+ *                               작업자는 이것을 안 읽는다(실측: spec 붙은 화면 11개에 있다)
+ * stationScenarioVersion 뺀다   그 출처의 판. 지금 전부 1이고, **시드를 다시 돌려 2가 되면 그려진 것은
+ *                               하나도 안 바뀌는데 서명이 전부 낡는다**(실측: 10개)
+ * type · view · counts   남긴다  구조 · 묶음 타일 종류 · 양품/불량 — 작업자가 읽거나 만지는 내용이다
+ * removable              남긴다  줄을 뺄 수 있나 — 작업자가 만지는 것이다
+ * ```
+ *
+ * **값어치로 예외를 두지 않는다.** 「이건 중요하니까 세자」가 한 번 들어오면 기준이 사라진다.
+ *
+ * ⚠ 이름으로 빼므로 **부품 자료 안에 같은 이름의 칸이 있으면 그것도 빠진다.** 지금 도안에는 없고,
+ * 그런 칸이 생기면 그때는 경로로 빼는 수밖에 없다.
+ *
+ * [합의했다] ADR-0047 ④ — Shop Floor 가 저장된 도안 둘(저작면 것 · 편집기를 지난 것)을 견줘 찾았다.
+ *
+ * ── 글자로 와도 받는다. **그것이 실제 경로다** ────────────────────────────
+ * `Board.model` 은 **문자열 칸**이다(text). 그래서 상신하는 쪽이 읽어 넘기는 값도 글자이고, 그것을
+ * 그대로 해시하면 **정규화가 한 번도 안 돈다** — 같은 도안이라도 저장된 글자의 키 순서나 들여쓰기가
+ * 달라지면 지문이 달라지고, 그 순간 모든 서명이 낡는다. 막으려고 만든 결함을 막는 코드가 그대로
+ * 만들어 내는 자리였다(2026-09-16에 실제로 그랬다).
+ *
+ * 그래서 글자면 **먼저 읽어서** 정규화한다. 못 읽는 글자는 지어내지 않고 글자 그대로 해시한다 —
+ * 여기서 던지면 발행 관문이 그 화면에서 멈춘다.
+ *
+ * [합의했다] operato-application/adr/ADR-0047.md ④
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+function screenModelDigest(model) {
+    return (0, node_crypto_1.createHash)('sha256').update(stable(parsed(model))).digest('hex');
+}
+/** 글자로 온 도안은 읽어서 본다. 못 읽으면 글자 그대로 — 던지지 않는다. */
+function parsed(model) {
+    if (typeof model !== 'string') {
+        return model;
+    }
+    try {
+        return JSON.parse(model);
+    }
+    catch {
+        return model;
+    }
+}
+/** 보기 상태 · 색인 · 출처 — 읽는 것을 안 바꾸면서 지문을 흔드는 칸들. */
+const NOT_WHAT_THE_OPERATOR_READS = new Set(['threed', 'refid', 'stationScenario', 'stationScenarioVersion']);
+/** 키를 정렬해 직렬화한다. 배열은 그대로 — 순서가 뜻이다. */
+function stable(value) {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value ?? null);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map(stable).join(',')}]`;
+    }
+    const entries = Object.entries(value)
+        /* `undefined` 는 JSON 에서 사라진다 — 여기서도 없는 것으로 읽어 둘이 안 갈리게 한다. */
+        .filter(([, one]) => one !== undefined)
+        /* 작업자가 읽는 것이 아닌 칸은 빼고 센다(위 표). 부품 안에도 붙으므로 여기서 걸러야 재귀로 빠진다. */
+        .filter(([key]) => !NOT_WHAT_THE_OPERATOR_READS.has(key))
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return `{${entries.map(([key, one]) => `${JSON.stringify(key)}:${stable(one)}`).join(',')}}`;
+}
+//# sourceMappingURL=screen-model-digest.js.map

package/dist-server/service/station/screen-model-digest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen-model-digest.js","sourceRoot":"","sources":["../../../server/service/station/screen-model-digest.ts"],"names":[],"mappings":";;AA6DA,8CAEC;AA/DD,6CAAwC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,SAAgB,iBAAiB,CAAC,KAAc;IAC9C,OAAO,IAAA,wBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AACzE,CAAC;AAED,gDAAgD;AAChD,SAAS,MAAM,CAAC,KAAc;IAC5B,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,KAAK,CAAA;IACd,CAAC;IAED,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC1B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAA;IACd,CAAC;AACH,CAAC;AAED,iDAAiD;AACjD,MAAM,2BAA2B,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,CAAC,CAAC,CAAA;AAE7G,uCAAuC;AACvC,SAAS,MAAM,CAAC,KAAc;IAC5B,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAChD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,IAAI,CAAC,CAAA;IACtC,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;IAC3C,CAAC;IAED,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,KAAgC,CAAC;QAC9D,8DAA8D;SAC7D,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,KAAK,SAAS,CAAC;QACvC,+DAA+D;SAC9D,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,2BAA2B,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;SACxD,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAEnD,OAAO,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;AAC9F,CAAC","sourcesContent":["import { createHash } from 'node:crypto'\n\n/**\n * 화면 도안 한 판의 **지문** — 서명이 어느 판에 걸린 것인지 가리는 값.\n *\n * ═══════════════════════════════════════════════════════════════════════════\n * ── 왜 필요한가 ───────────────────────────────────────────────────────────\n * 통제 문서는 **판마다** 승인받는다(ISO 9001 7.5.3). 그런데 서명이 화면(`boardId`)에만 걸려 있으면\n * v1 을 승인한 서명 위로 **v2 가 그대로 나간다** — 통제가 이름만 남는 자리다.\n *\n * 번호로는 못 묶는다. `Board.version` 은 발행할 때 정해지고, 상신하는 시점에는 그 번호가 없다.\n * 그래서 **그때 도안 자체**를 굳힌다 — `shownAtSigning` 이 결재자에게 보인 문장을 굳히는 것과 같다.\n *\n * ── 정규화가 이 값의 전부다 ───────────────────────────────────────────────\n * 키 순서만 달라져도 지문이 바뀌면 **저장할 때마다 재결재**가 되고, 관문은 곧 소음이 되어 사람이\n * 끄게 된다. 그래서 키를 정렬해 직렬화한 뒤 해시한다.\n *\n * **배열 순서는 안 건드린다.** 도안에서 순서는 뜻이다 — 겹치는 순서가 바뀌면 작업자가 보는 것이\n * 달라진다. 정렬하면 그 변화가 지문에서 사라진다.\n *\n * ── 한 자리에서만 만든다 ─────────────────────────────────────────────────\n * 상신하는 쪽과 발행 관문이 **같은 함수**를 부른다. 두 벌로 두면 한쪽이 정규화를 조금 다르게 하는 날\n * 모든 서명이 낡은 것으로 읽히고, 아무도 이유를 모른다.\n *\n * ── 빼는 칸: **작업자가 화면에서 읽는 것이 아닌 칸** ──────────────────────\n * 도안 안에 저장할 때마다(또는 한 번) 바뀌는 칸이 있으면 이 값이 달라지고, **내용이 안 바뀐 화면의\n * 서명이 낡는다.** 기준은 하나다 — 그 칸이 작업자가 화면에서 읽는 것을 바꾸는가.\n *\n * ```\n * threed                 뺀다   2D/3D 토글의 보기 상태. 3D 로 보다가 저장하면 읽는 것은 그대로인데 지문이 바뀐다\n * refid                  뺀다   things-scene 이 없을 때 한 번 매겨 저장하는 식별 색인\n *                               (RootContainer.addRefidIndex → set('refid'); 있으면 그대로 둔다)\n *                               세션마다 바뀌진 않지만 **저작면 도안이 편집기를 처음 지날 때** 붙어\n *                               지문이 한 번 바뀐다. 부품마다 붙으므로 **재귀로** 뺀다\n * stationScenario        뺀다   어느 시나리오가 만들었나 — **출처**다. 'rework' 'packing' 같은 값이고\n *                               작업자는 이것을 안 읽는다(실측: spec 붙은 화면 11개에 있다)\n * stationScenarioVersion 뺀다   그 출처의 판. 지금 전부 1이고, **시드를 다시 돌려 2가 되면 그려진 것은\n *                               하나도 안 바뀌는데 서명이 전부 낡는다**(실측: 10개)\n * type · view · counts   남긴다  구조 · 묶음 타일 종류 · 양품/불량 — 작업자가 읽거나 만지는 내용이다\n * removable              남긴다  줄을 뺄 수 있나 — 작업자가 만지는 것이다\n * ```\n *\n * **값어치로 예외를 두지 않는다.** 「이건 중요하니까 세자」가 한 번 들어오면 기준이 사라진다.\n *\n * ⚠ 이름으로 빼므로 **부품 자료 안에 같은 이름의 칸이 있으면 그것도 빠진다.** 지금 도안에는 없고,\n * 그런 칸이 생기면 그때는 경로로 빼는 수밖에 없다.\n *\n * [합의했다] ADR-0047 ④ — Shop Floor 가 저장된 도안 둘(저작면 것 · 편집기를 지난 것)을 견줘 찾았다.\n *\n * ── 글자로 와도 받는다. **그것이 실제 경로다** ────────────────────────────\n * `Board.model` 은 **문자열 칸**이다(text). 그래서 상신하는 쪽이 읽어 넘기는 값도 글자이고, 그것을\n * 그대로 해시하면 **정규화가 한 번도 안 돈다** — 같은 도안이라도 저장된 글자의 키 순서나 들여쓰기가\n * 달라지면 지문이 달라지고, 그 순간 모든 서명이 낡는다. 막으려고 만든 결함을 막는 코드가 그대로\n * 만들어 내는 자리였다(2026-09-16에 실제로 그랬다).\n *\n * 그래서 글자면 **먼저 읽어서** 정규화한다. 못 읽는 글자는 지어내지 않고 글자 그대로 해시한다 —\n * 여기서 던지면 발행 관문이 그 화면에서 멈춘다.\n *\n * [합의했다] operato-application/adr/ADR-0047.md ④\n * ═══════════════════════════════════════════════════════════════════════════\n */\nexport function screenModelDigest(model: unknown): string {\n  return createHash('sha256').update(stable(parsed(model))).digest('hex')\n}\n\n/** 글자로 온 도안은 읽어서 본다. 못 읽으면 글자 그대로 — 던지지 않는다. */\nfunction parsed(model: unknown): unknown {\n  if (typeof model !== 'string') {\n    return model\n  }\n\n  try {\n    return JSON.parse(model)\n  } catch {\n    return model\n  }\n}\n\n/** 보기 상태 · 색인 · 출처 — 읽는 것을 안 바꾸면서 지문을 흔드는 칸들. */\nconst NOT_WHAT_THE_OPERATOR_READS = new Set(['threed', 'refid', 'stationScenario', 'stationScenarioVersion'])\n\n/** 키를 정렬해 직렬화한다. 배열은 그대로 — 순서가 뜻이다. */\nfunction stable(value: unknown): string {\n  if (value === null || typeof value !== 'object') {\n    return JSON.stringify(value ?? null)\n  }\n\n  if (Array.isArray(value)) {\n    return `[${value.map(stable).join(',')}]`\n  }\n\n  const entries = Object.entries(value as Record<string, unknown>)\n    /* `undefined` 는 JSON 에서 사라진다 — 여기서도 없는 것으로 읽어 둘이 안 갈리게 한다. */\n    .filter(([, one]) => one !== undefined)\n    /* 작업자가 읽는 것이 아닌 칸은 빼고 센다(위 표). 부품 안에도 붙으므로 여기서 걸러야 재귀로 빠진다. */\n    .filter(([key]) => !NOT_WHAT_THE_OPERATOR_READS.has(key))\n    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n\n  return `{${entries.map(([key, one]) => `${JSON.stringify(key)}:${stable(one)}`).join(',')}}`\n}\n"]}

package/dist-server/service/station/staged-material.d.ts

@@ -0,0 +1,62 @@
+/**
+ * 스캔한 자재가 이 작업지시에 들어갈 것인가 — **순수 판단.**
+ *
+ * ── 오투입은 며칠 뒤에 드러난다 ────────────────────────────────────────────
+ * 비슷하게 생긴 원료를 잘못 넣으면 그날은 아무 일도 안 일어난다. 검사에서 걸리거나, 걸리지 않으면
+ * 고객이 찾아낸다. 막을 수 있는 자리는 **투입하는 순간**뿐이고, 그 순간에 시스템이 아는 것은 스캔한
+ * 라벨 하나다.
+ *
+ * ── 대조할 근거가 없으면 없다고 한다 ───────────────────────────────────────
+ * 레시피가 안 붙은 지시가 정상으로 있다. 그때 「맞다」고 하면 확인한 적 없는 것을 확인했다고 말하는
+ * 것이고, 「틀리다」고 하면 정상 작업을 막는다. 둘 다 아니고 **근거가 없다**고 말한다.
+ *
+ * ── 마스터에 없는 것과 이 지시가 안 쓰는 것은 다르다 ───────────────────────
+ * 앞은 라벨이 깨졌거나 등록이 안 된 것이고, 뒤는 **오투입**이다. 사람이 할 일이 다르므로 갈라 놓는다.
+ */
+export type StagedVerdict = 
+/** 이 지시가 쓰는 자재다. */
+{
+    kind: 'belongs';
+    materialName: string;
+}
+/**
+ * 마스터에는 있는데 **이 지시가 쓰지 않는다.** 오투입이다.
+ *
+ * `expected` 는 이 지시가 실제로 쓰는 것들 — 화면이 「이것 대신 이것들입니다」라고 말할 수 있다.
+ */
+ | {
+    kind: 'not-in-recipe';
+    materialName: string;
+    expected: string[];
+}
+/** 이 품번이 마스터에 없다. 라벨이 깨졌거나 등록이 안 된 것이다. */
+ | {
+    kind: 'unknown-item';
+    gtin: string;
+}
+/** 레시피가 안 붙어 있어 대조할 근거가 없다. 막지 않는다. */
+ | {
+    kind: 'no-recipe';
+    materialName: string;
+};
+export interface StagedInput {
+    /** 스캔에서 나온 품번(AI 01). */
+    gtin: string;
+    /** 그 품번으로 찾은 자재의 이름. 못 찾았으면 없다. */
+    materialName?: string;
+    /**
+     * 이 지시의 레시피가 쓰는 자재들 — `RecipePart.material`.
+     *
+     * 레시피가 안 붙었으면 없다. **빈 배열과 없는 것은 다르다** — 빈 배열은 「아무것도 안 쓰는 레시피」이고
+     * 그런 레시피는 없다시피 하지만, 없는 것은 「레시피가 없다」이다.
+     */
+    recipeInputs?: string[];
+}
+export declare function judgeStaged(input: StagedInput): StagedVerdict;
+/**
+ * 레시피의 투입 목록에서 자재 이름만 뽑는다.
+ *
+ * 커널 `RecipePart` 는 `material`(자재 키)을 든다. 그 이름이 아닌 칸에서 값을 끌어오지 않는다 — 끌어오면
+ * 레시피 모양이 바뀌는 날 **조용히 빈 목록**이 되고, 그러면 모든 스캔이 「이 지시가 안 쓴다」가 된다.
+ */
+export declare function recipeInputNames(inputs: Record<string, unknown>[] | undefined): string[] | undefined;

package/dist-server/service/station/staged-material.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * 스캔한 자재가 이 작업지시에 들어갈 것인가 — **순수 판단.**
+ *
+ * ── 오투입은 며칠 뒤에 드러난다 ────────────────────────────────────────────
+ * 비슷하게 생긴 원료를 잘못 넣으면 그날은 아무 일도 안 일어난다. 검사에서 걸리거나, 걸리지 않으면
+ * 고객이 찾아낸다. 막을 수 있는 자리는 **투입하는 순간**뿐이고, 그 순간에 시스템이 아는 것은 스캔한
+ * 라벨 하나다.
+ *
+ * ── 대조할 근거가 없으면 없다고 한다 ───────────────────────────────────────
+ * 레시피가 안 붙은 지시가 정상으로 있다. 그때 「맞다」고 하면 확인한 적 없는 것을 확인했다고 말하는
+ * 것이고, 「틀리다」고 하면 정상 작업을 막는다. 둘 다 아니고 **근거가 없다**고 말한다.
+ *
+ * ── 마스터에 없는 것과 이 지시가 안 쓰는 것은 다르다 ───────────────────────
+ * 앞은 라벨이 깨졌거나 등록이 안 된 것이고, 뒤는 **오투입**이다. 사람이 할 일이 다르므로 갈라 놓는다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.judgeStaged = judgeStaged;
+exports.recipeInputNames = recipeInputNames;
+function judgeStaged(input) {
+    if (!input.materialName) {
+        return { kind: 'unknown-item', gtin: input.gtin };
+    }
+    if (!input.recipeInputs) {
+        return { kind: 'no-recipe', materialName: input.materialName };
+    }
+    if (input.recipeInputs.includes(input.materialName)) {
+        return { kind: 'belongs', materialName: input.materialName };
+    }
+    return { kind: 'not-in-recipe', materialName: input.materialName, expected: input.recipeInputs };
+}
+/**
+ * 레시피의 투입 목록에서 자재 이름만 뽑는다.
+ *
+ * 커널 `RecipePart` 는 `material`(자재 키)을 든다. 그 이름이 아닌 칸에서 값을 끌어오지 않는다 — 끌어오면
+ * 레시피 모양이 바뀌는 날 **조용히 빈 목록**이 되고, 그러면 모든 스캔이 「이 지시가 안 쓴다」가 된다.
+ */
+function recipeInputNames(inputs) {
+    if (!inputs) {
+        return undefined;
+    }
+    return inputs.map(part => part.material).filter((material) => typeof material === 'string' && material.length > 0);
+}
+//# sourceMappingURL=staged-material.js.map

package/dist-server/service/station/staged-material.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"staged-material.js","sourceRoot":"","sources":["../../../server/service/station/staged-material.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AA8BH,kCAcC;AAQD,4CAMC;AA5BD,SAAgB,WAAW,CAAC,KAAkB;IAC5C,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;QACxB,OAAO,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAA;IACnD,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;QACxB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,CAAA;IAChE,CAAC;IAED,IAAI,KAAK,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC;QACpD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,CAAA;IAC9D,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,YAAY,EAAE,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,KAAK,CAAC,YAAY,EAAE,CAAA;AAClG,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gBAAgB,CAAC,MAA6C;IAC5E,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,OAAO,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAsB,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;AACxI,CAAC","sourcesContent":["/**\n * 스캔한 자재가 이 작업지시에 들어갈 것인가 — **순수 판단.**\n *\n * ── 오투입은 며칠 뒤에 드러난다 ────────────────────────────────────────────\n * 비슷하게 생긴 원료를 잘못 넣으면 그날은 아무 일도 안 일어난다. 검사에서 걸리거나, 걸리지 않으면\n * 고객이 찾아낸다. 막을 수 있는 자리는 **투입하는 순간**뿐이고, 그 순간에 시스템이 아는 것은 스캔한\n * 라벨 하나다.\n *\n * ── 대조할 근거가 없으면 없다고 한다 ───────────────────────────────────────\n * 레시피가 안 붙은 지시가 정상으로 있다. 그때 「맞다」고 하면 확인한 적 없는 것을 확인했다고 말하는\n * 것이고, 「틀리다」고 하면 정상 작업을 막는다. 둘 다 아니고 **근거가 없다**고 말한다.\n *\n * ── 마스터에 없는 것과 이 지시가 안 쓰는 것은 다르다 ───────────────────────\n * 앞은 라벨이 깨졌거나 등록이 안 된 것이고, 뒤는 **오투입**이다. 사람이 할 일이 다르므로 갈라 놓는다.\n */\n\nexport type StagedVerdict =\n  /** 이 지시가 쓰는 자재다. */\n  | { kind: 'belongs'; materialName: string }\n  /**\n   * 마스터에는 있는데 **이 지시가 쓰지 않는다.** 오투입이다.\n   *\n   * `expected` 는 이 지시가 실제로 쓰는 것들 — 화면이 「이것 대신 이것들입니다」라고 말할 수 있다.\n   */\n  | { kind: 'not-in-recipe'; materialName: string; expected: string[] }\n  /** 이 품번이 마스터에 없다. 라벨이 깨졌거나 등록이 안 된 것이다. */\n  | { kind: 'unknown-item'; gtin: string }\n  /** 레시피가 안 붙어 있어 대조할 근거가 없다. 막지 않는다. */\n  | { kind: 'no-recipe'; materialName: string }\n\nexport interface StagedInput {\n  /** 스캔에서 나온 품번(AI 01). */\n  gtin: string\n  /** 그 품번으로 찾은 자재의 이름. 못 찾았으면 없다. */\n  materialName?: string\n  /**\n   * 이 지시의 레시피가 쓰는 자재들 — `RecipePart.material`.\n   *\n   * 레시피가 안 붙었으면 없다. **빈 배열과 없는 것은 다르다** — 빈 배열은 「아무것도 안 쓰는 레시피」이고\n   * 그런 레시피는 없다시피 하지만, 없는 것은 「레시피가 없다」이다.\n   */\n  recipeInputs?: string[]\n}\n\nexport function judgeStaged(input: StagedInput): StagedVerdict {\n  if (!input.materialName) {\n    return { kind: 'unknown-item', gtin: input.gtin }\n  }\n\n  if (!input.recipeInputs) {\n    return { kind: 'no-recipe', materialName: input.materialName }\n  }\n\n  if (input.recipeInputs.includes(input.materialName)) {\n    return { kind: 'belongs', materialName: input.materialName }\n  }\n\n  return { kind: 'not-in-recipe', materialName: input.materialName, expected: input.recipeInputs }\n}\n\n/**\n * 레시피의 투입 목록에서 자재 이름만 뽑는다.\n *\n * 커널 `RecipePart` 는 `material`(자재 키)을 든다. 그 이름이 아닌 칸에서 값을 끌어오지 않는다 — 끌어오면\n * 레시피 모양이 바뀌는 날 **조용히 빈 목록**이 되고, 그러면 모든 스캔이 「이 지시가 안 쓴다」가 된다.\n */\nexport function recipeInputNames(inputs: Record<string, unknown>[] | undefined): string[] | undefined {\n  if (!inputs) {\n    return undefined\n  }\n\n  return inputs.map(part => part.material).filter((material): material is string => typeof material === 'string' && material.length > 0)\n}\n"]}

package/dist-server/service/station/station-argument-sources.d.ts

@@ -0,0 +1,31 @@
+import type { StationArgumentSource } from './station-flow.js';
+/**
+ * Where an argument's value would come from, if nobody said otherwise.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ## Why guess at all
+ *
+ * `reportProduction` takes fourteen fields and eleven of them have exactly one sensible answer —
+ * the equipment is the station's equipment, the operator is whoever scanned in, `status` is
+ * whatever the button means. Making an author answer fourteen questions to reach the two that are
+ * actually a decision is how a tool stops being used.
+ *
+ * ## Why it is a suggestion and not a rule
+ *
+ * Every one is overridable, and the composer shows what was chosen rather than hiding it. A guess
+ * the author cannot see or change is worse than no guess: the day it is wrong, the report is wrong
+ * and nothing on the screen says why.
+ *
+ * ## Why this is its own file
+ *
+ * It is a table of names and nothing else — no schema, no repositories, no entity imports. That
+ * keeps it testable on its own, which matters here more than usual: **every value in it is a name
+ * that lives in another file**, and a wrong one produces no error at all. The field simply goes out
+ * empty, and a production report arrives with no equipment on it.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+export declare function suggestSource(field: string): StationArgumentSource | undefined;
+/** The axes this table points at — the tests check every one of them is real. */
+export declare function suggestedAxes(): string[];
+/** Which fields this table can answer — the composer greys those rows as 「automatic」. */
+export declare function suggestableFields(): string[];

package/dist-server/service/station/station-argument-sources.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.suggestSource = suggestSource;
+exports.suggestedAxes = suggestedAxes;
+exports.suggestableFields = suggestableFields;
+/**
+ * Where an argument's value would come from, if nobody said otherwise.
+ *
+ * ═══════════════════════════════════════════════════════════════════════════
+ * ## Why guess at all
+ *
+ * `reportProduction` takes fourteen fields and eleven of them have exactly one sensible answer —
+ * the equipment is the station's equipment, the operator is whoever scanned in, `status` is
+ * whatever the button means. Making an author answer fourteen questions to reach the two that are
+ * actually a decision is how a tool stops being used.
+ *
+ * ## Why it is a suggestion and not a rule
+ *
+ * Every one is overridable, and the composer shows what was chosen rather than hiding it. A guess
+ * the author cannot see or change is worse than no guess: the day it is wrong, the report is wrong
+ * and nothing on the screen says why.
+ *
+ * ## Why this is its own file
+ *
+ * It is a table of names and nothing else — no schema, no repositories, no entity imports. That
+ * keeps it testable on its own, which matters here more than usual: **every value in it is a name
+ * that lives in another file**, and a wrong one produces no error at all. The field simply goes out
+ * empty, and a production report arrives with no equipment on it.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+function suggestSource(field) {
+    /* The step's own meaning settles these — a finish button knows it is finishing. */
+    if (STEP_DECIDES.has(field)) {
+        return { from: 'step' };
+    }
+    const axis = CONTEXT_AXIS[field];
+    return axis ? { from: 'context', axis } : undefined;
+}
+/** Settled by what the button means, not by anything the author types. */
+const STEP_DECIDES = new Set(['status', 'startTime', 'endTime', 'at', 'fromTime', 'toTime']);
+/**
+ * Field name → the context axis that answers it.
+ *
+ * The axis names are the ones `stationBindingNames()` lists. A name that is not an axis resolves
+ * to nothing at run time, so the tests check every one of these against that list rather than
+ * trusting it.
+ */
+const CONTEXT_AXIS = {
+    name: 'task.name',
+    operationKey: 'station.operation',
+    jobOrderName: 'order.name',
+    locationName: 'location.name',
+    equipmentNames: 'station.equipment',
+    equipmentName: 'station.equipment',
+    personNames: 'operator.name',
+    testableObjectId: 'order.name'
+};
+/** The axes this table points at — the tests check every one of them is real. */
+function suggestedAxes() {
+    return [...new Set(Object.values(CONTEXT_AXIS))];
+}
+/** Which fields this table can answer — the composer greys those rows as 「automatic」. */
+function suggestableFields() {
+    return [...STEP_DECIDES, ...Object.keys(CONTEXT_AXIS)];
+}
+//# sourceMappingURL=station-argument-sources.js.map

package/dist-server/service/station/station-argument-sources.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"station-argument-sources.js","sourceRoot":"","sources":["../../../server/service/station/station-argument-sources.ts"],"names":[],"mappings":";;AA2BA,sCASC;AAwBD,sCAEC;AAGD,8CAEC;AAjED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,SAAgB,aAAa,CAAC,KAAa;IACzC,mFAAmF;IACnF,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IACzB,CAAC;IAED,MAAM,IAAI,GAAG,YAAY,CAAC,KAAK,CAAC,CAAA;IAEhC,OAAO,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAA;AACrD,CAAC;AAED,0EAA0E;AAC1E,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAA;AAE5F;;;;;;GAMG;AACH,MAAM,YAAY,GAA2B;IAC3C,IAAI,EAAE,WAAW;IACjB,YAAY,EAAE,mBAAmB;IACjC,YAAY,EAAE,YAAY;IAC1B,YAAY,EAAE,eAAe;IAC7B,cAAc,EAAE,mBAAmB;IACnC,aAAa,EAAE,mBAAmB;IAClC,WAAW,EAAE,eAAe;IAC5B,gBAAgB,EAAE,YAAY;CAC/B,CAAA;AAED,iFAAiF;AACjF,SAAgB,aAAa;IAC3B,OAAO,CAAC,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAA;AAClD,CAAC;AAED,yFAAyF;AACzF,SAAgB,iBAAiB;IAC/B,OAAO,CAAC,GAAG,YAAY,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAA;AACxD,CAAC","sourcesContent":["import type { StationArgumentSource } from './station-flow.js'\n\n/**\n * Where an argument's value would come from, if nobody said otherwise.\n *\n * ═══════════════════════════════════════════════════════════════════════════\n * ## Why guess at all\n *\n * `reportProduction` takes fourteen fields and eleven of them have exactly one sensible answer —\n * the equipment is the station's equipment, the operator is whoever scanned in, `status` is\n * whatever the button means. Making an author answer fourteen questions to reach the two that are\n * actually a decision is how a tool stops being used.\n *\n * ## Why it is a suggestion and not a rule\n *\n * Every one is overridable, and the composer shows what was chosen rather than hiding it. A guess\n * the author cannot see or change is worse than no guess: the day it is wrong, the report is wrong\n * and nothing on the screen says why.\n *\n * ## Why this is its own file\n *\n * It is a table of names and nothing else — no schema, no repositories, no entity imports. That\n * keeps it testable on its own, which matters here more than usual: **every value in it is a name\n * that lives in another file**, and a wrong one produces no error at all. The field simply goes out\n * empty, and a production report arrives with no equipment on it.\n * ═══════════════════════════════════════════════════════════════════════════\n */\nexport function suggestSource(field: string): StationArgumentSource | undefined {\n  /* The step's own meaning settles these — a finish button knows it is finishing. */\n  if (STEP_DECIDES.has(field)) {\n    return { from: 'step' }\n  }\n\n  const axis = CONTEXT_AXIS[field]\n\n  return axis ? { from: 'context', axis } : undefined\n}\n\n/** Settled by what the button means, not by anything the author types. */\nconst STEP_DECIDES = new Set(['status', 'startTime', 'endTime', 'at', 'fromTime', 'toTime'])\n\n/**\n * Field name → the context axis that answers it.\n *\n * The axis names are the ones `stationBindingNames()` lists. A name that is not an axis resolves\n * to nothing at run time, so the tests check every one of these against that list rather than\n * trusting it.\n */\nconst CONTEXT_AXIS: Record<string, string> = {\n  name: 'task.name',\n  operationKey: 'station.operation',\n  jobOrderName: 'order.name',\n  locationName: 'location.name',\n  equipmentNames: 'station.equipment',\n  equipmentName: 'station.equipment',\n  personNames: 'operator.name',\n  testableObjectId: 'order.name'\n}\n\n/** The axes this table points at — the tests check every one of them is real. */\nexport function suggestedAxes(): string[] {\n  return [...new Set(Object.values(CONTEXT_AXIS))]\n}\n\n/** Which fields this table can answer — the composer greys those rows as 「automatic」. */\nexport function suggestableFields(): string[] {\n  return [...STEP_DECIDES, ...Object.keys(CONTEXT_AXIS)]\n}\n"]}

package/dist-server/service/station/station-assignment-choice.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Which drawn screen a station gets — **the picking rule, and nothing else.**
+ *
+ * Pure on purpose: the rule is the part that will be argued about, and arguing about it needs to be
+ * possible without a database and a shift calendar.
+ *
+ * ── The rule ───────────────────────────────────────────────────────────────
+ * A screen declares constraints on the axes it cares about and leaves the rest open. It is a
+ * candidate when **every constraint it declared** matches the station. Among candidates, the more
+ * specific one wins — the same rule the kernel already uses where a recipe line beats a general
+ * material spec.
+ *
+ * ── Specificity is a partial order, not a ranking ──────────────────────────
+ * "More specific" means **constraining a strict superset of the axes**: a screen for
+ * `{workCenter, operation}` beats one for `{workCenter}`, because it says everything the other says and more.
+ *
+ * What it deliberately does not do is weigh axes against each other. `{equipment}` versus
+ * `{workCenter, operation}` — one names a single machine, the other two broader things, and any ordering
+ * between them would be a number somebody made up. Inventing that weight is how a rule becomes
+ * folklore that nobody can predict. So they are a **tie**, and a tie is decided by a priority
+ * somebody wrote down.
+ *
+ * ── A tie nobody resolved is reported, not hidden ──────────────────────────
+ * If two screens tie and no priority separates them, one still has to be drawn — but the answer says
+ * it was ambiguous and names the others. Quietly dropping one is the worst outcome: the factory sees
+ * a screen, cannot tell why that one, and changing the other has no effect.
+ */
+/** The axes a screen can constrain. Everything is optional — absent means "any". */
+export interface StationAssignmentSelector {
+    equipmentName?: string;
+    equipmentClassId?: string;
+    workCenterName?: string;
+    operationKey?: string;
+    routeKey?: string;
+    materialClassId?: string;
+    personnelClassId?: string;
+}
+/** One assignment: a board, and when to show it. */
+export interface StationAssignmentRule extends StationAssignmentSelector {
+    name: string;
+    /** 그릴 화면의 이름. 판은 배정이 못 박았을 때만 있다. */
+    boardId: string;
+    /** Breaks a tie between equally specific screens. Higher wins. */
+    priority?: number;
+}
+/**
+ * What the station actually is right now — the same five axes, plus the classes it belongs to.
+ *
+ * The axis names are the contract's, not this factory's (ADR-0083 decision 5): `workCenterName`
+ * covers a production line, a storage zone and a yard area, which is what lets the warehouse select
+ * on the same axis without a word of ours in it.
+ */
+export interface StationAssignmentSituation {
+    equipmentName?: string;
+    equipmentClassIds?: string[];
+    workCenterName?: string;
+    operationKey?: string;
+    routeKey?: string;
+    materialClassIds?: string[];
+    personnelClassIds?: string[];
+}
+export interface StationAssignmentChoice {
+    name: string;
+    boardId: string;
+    /** Which axes this screen constrained. The admin screen says "chosen because …" from this. */
+    matchedOn: (keyof StationAssignmentSelector)[];
+    /**
+     * Equally specific screens that nothing separated.
+     *
+     * Empty is the normal case. Non-empty means the factory has two answers to the same question and
+     * somebody has to write a priority — the screen drawn is deterministic but arbitrary.
+     */
+    ambiguousWith: string[];
+}
+/**
+ * Pick one. Nothing fits → nothing is drawn, and the caller says so rather than showing a default.
+ *
+ * A screen that appears when nothing was assigned teaches the factory that assignment does not
+ * matter, and then nobody trusts what they see.
+ */
+export declare function chooseStationAssignment(rules: readonly StationAssignmentRule[], situation: StationAssignmentSituation): StationAssignmentChoice | undefined;

package/dist-server/service/station/station-assignment-choice.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Which drawn screen a station gets — **the picking rule, and nothing else.**
+ *
+ * Pure on purpose: the rule is the part that will be argued about, and arguing about it needs to be
+ * possible without a database and a shift calendar.
+ *
+ * ── The rule ───────────────────────────────────────────────────────────────
+ * A screen declares constraints on the axes it cares about and leaves the rest open. It is a
+ * candidate when **every constraint it declared** matches the station. Among candidates, the more
+ * specific one wins — the same rule the kernel already uses where a recipe line beats a general
+ * material spec.
+ *
+ * ── Specificity is a partial order, not a ranking ──────────────────────────
+ * "More specific" means **constraining a strict superset of the axes**: a screen for
+ * `{workCenter, operation}` beats one for `{workCenter}`, because it says everything the other says and more.
+ *
+ * What it deliberately does not do is weigh axes against each other. `{equipment}` versus
+ * `{workCenter, operation}` — one names a single machine, the other two broader things, and any ordering
+ * between them would be a number somebody made up. Inventing that weight is how a rule becomes
+ * folklore that nobody can predict. So they are a **tie**, and a tie is decided by a priority
+ * somebody wrote down.
+ *
+ * ── A tie nobody resolved is reported, not hidden ──────────────────────────
+ * If two screens tie and no priority separates them, one still has to be drawn — but the answer says
+ * it was ambiguous and names the others. Quietly dropping one is the worst outcome: the factory sees
+ * a screen, cannot tell why that one, and changing the other has no effect.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseStationAssignment = chooseStationAssignment;
+const SINGLE_AXES = ['equipmentName', 'workCenterName', 'operationKey', 'routeKey'];
+const CLASS_AXES = [
+    ['equipmentClassId', 'equipmentClassIds'],
+    ['materialClassId', 'materialClassIds'],
+    ['personnelClassId', 'personnelClassIds']
+];
+/** Which axes a rule constrains. Its specificity is this set, not its size. */
+function constrainedAxes(rule) {
+    const axes = [];
+    for (const axis of SINGLE_AXES) {
+        if (rule[axis]) {
+            axes.push(axis);
+        }
+    }
+    for (const [axis] of CLASS_AXES) {
+        if (rule[axis]) {
+            axes.push(axis);
+        }
+    }
+    return axes;
+}
+/**
+ * Does every constraint this rule declared hold here.
+ *
+ * An axis the situation does not know is **not a match.** A screen asking for welders should not be
+ * drawn before anyone has scanned in — that is the moment it would matter most that we do not guess.
+ */
+function fits(rule, situation) {
+    for (const axis of SINGLE_AXES) {
+        if (rule[axis] && rule[axis] !== situation[axis]) {
+            return false;
+        }
+    }
+    for (const [axis, membership] of CLASS_AXES) {
+        const wanted = rule[axis];
+        if (wanted && !(situation[membership] ?? []).includes(wanted)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isSuperset(of, than) {
+    return than.every(axis => of.includes(axis)) && of.length > than.length;
+}
+/**
+ * Pick one. Nothing fits → nothing is drawn, and the caller says so rather than showing a default.
+ *
+ * A screen that appears when nothing was assigned teaches the factory that assignment does not
+ * matter, and then nobody trusts what they see.
+ */
+function chooseStationAssignment(rules, situation) {
+    const candidates = rules.filter(rule => fits(rule, situation));
+    if (!candidates.length) {
+        return undefined;
+    }
+    const withAxes = candidates.map(rule => ({ rule, axes: constrainedAxes(rule) }));
+    /* Drop anything another candidate says strictly more than. */
+    const finalists = withAxes.filter(one => !withAxes.some(other => isSuperset(other.axes, one.axes)));
+    const best = finalists.reduce((winner, one) => {
+        const byPriority = (one.rule.priority ?? 0) - (winner.rule.priority ?? 0);
+        if (byPriority !== 0) {
+            return byPriority > 0 ? one : winner;
+        }
+        /* Same priority, neither more specific. Pick by name so the same factory sees the same screen. */
+        return one.rule.name < winner.rule.name ? one : winner;
+    });
+    const tied = finalists.filter(one => one.rule !== best.rule && (one.rule.priority ?? 0) === (best.rule.priority ?? 0));
+    return {
+        name: best.rule.name,
+        boardId: best.rule.boardId,
+        matchedOn: best.axes,
+        ambiguousWith: tied.map(one => one.rule.name).sort()
+    };
+}
+//# sourceMappingURL=station-assignment-choice.js.map

package/dist-server/service/station/station-assignment-choice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"station-assignment-choice.js","sourceRoot":"","sources":["../../../server/service/station/station-assignment-choice.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Which drawn screen a station gets — **the picking rule, and nothing else.**\n *\n * Pure on purpose: the rule is the part that will be argued about, and arguing about it needs to be\n * possible without a database and a shift calendar.\n *\n * ── The rule ───────────────────────────────────────────────────────────────\n * A screen declares constraints on the axes it cares about and leaves the rest open. It is a\n * candidate when **every constraint it declared** matches the station. Among candidates, the more\n * specific one wins — the same rule the kernel already uses where a recipe line beats a general\n * material spec.\n *\n * ── Specificity is a partial order, not a ranking ──────────────────────────\n * \"More specific\" means **constraining a strict superset of the axes**: a screen for\n * `{workCenter, operation}` beats one for `{workCenter}`, because it says everything the other says and more.\n *\n * What it deliberately does not do is weigh axes against each other. `{equipment}` versus\n * `{workCenter, operation}` — one names a single machine, the other two broader things, and any ordering\n * between them would be a number somebody made up. Inventing that weight is how a rule becomes\n * folklore that nobody can predict. So they are a **tie**, and a tie is decided by a priority\n * somebody wrote down.\n *\n * ── A tie nobody resolved is reported, not hidden ──────────────────────────\n * If two screens tie and no priority separates them, one still has to be drawn — but the answer says\n * it was ambiguous and names the others. Quietly dropping one is the worst outcome: the factory sees\n * a screen, cannot tell why that one, and changing the other has no effect.\n */\n\n/** The axes a screen can constrain. Everything is optional — absent means \"any\". */\nexport interface StationAssignmentSelector {\n  equipmentName?: string\n  equipmentClassId?: string\n  workCenterName?: string\n  operationKey?: string\n  routeKey?: string\n  materialClassId?: string\n  personnelClassId?: string\n}\n\n/** One assignment: a board, and when to show it. */\nexport interface StationAssignmentRule extends StationAssignmentSelector {\n  name: string\n  /** 그릴 화면의 이름. 판은 배정이 못 박았을 때만 있다. */\n  boardId: string\n  /** Breaks a tie between equally specific screens. Higher wins. */\n  priority?: number\n}\n\n/**\n * What the station actually is right now — the same five axes, plus the classes it belongs to.\n *\n * The axis names are the contract's, not this factory's (ADR-0083 decision 5): `workCenterName`\n * covers a production line, a storage zone and a yard area, which is what lets the warehouse select\n * on the same axis without a word of ours in it.\n */\nexport interface StationAssignmentSituation {\n  equipmentName?: string\n  equipmentClassIds?: string[]\n  workCenterName?: string\n  operationKey?: string\n  routeKey?: string\n  materialClassIds?: string[]\n  personnelClassIds?: string[]\n}\n\nexport interface StationAssignmentChoice {\n  name: string\n  boardId: string\n  /** Which axes this screen constrained. The admin screen says \"chosen because …\" from this. */\n  matchedOn: (keyof StationAssignmentSelector)[]\n  /**\n   * Equally specific screens that nothing separated.\n   *\n   * Empty is the normal case. Non-empty means the factory has two answers to the same question and\n   * somebody has to write a priority — the screen drawn is deterministic but arbitrary.\n   */\n  ambiguousWith: string[]\n}\n\nconst SINGLE_AXES = ['equipmentName', 'workCenterName', 'operationKey', 'routeKey'] as const\n\nconst CLASS_AXES = [\n  ['equipmentClassId', 'equipmentClassIds'],\n  ['materialClassId', 'materialClassIds'],\n  ['personnelClassId', 'personnelClassIds']\n] as const\n\n/** Which axes a rule constrains. Its specificity is this set, not its size. */\nfunction constrainedAxes(rule: StationAssignmentRule): (keyof StationAssignmentSelector)[] {\n  const axes: (keyof StationAssignmentSelector)[] = []\n\n  for (const axis of SINGLE_AXES) {\n    if (rule[axis]) {\n      axes.push(axis)\n    }\n  }\n\n  for (const [axis] of CLASS_AXES) {\n    if (rule[axis]) {\n      axes.push(axis)\n    }\n  }\n\n  return axes\n}\n\n/**\n * Does every constraint this rule declared hold here.\n *\n * An axis the situation does not know is **not a match.** A screen asking for welders should not be\n * drawn before anyone has scanned in — that is the moment it would matter most that we do not guess.\n */\nfunction fits(rule: StationAssignmentRule, situation: StationAssignmentSituation): boolean {\n  for (const axis of SINGLE_AXES) {\n    if (rule[axis] && rule[axis] !== situation[axis]) {\n      return false\n    }\n  }\n\n  for (const [axis, membership] of CLASS_AXES) {\n    const wanted = rule[axis]\n\n    if (wanted && !(situation[membership] ?? []).includes(wanted)) {\n      return false\n    }\n  }\n\n  return true\n}\n\nfunction isSuperset(of: (keyof StationAssignmentSelector)[], than: (keyof StationAssignmentSelector)[]): boolean {\n  return than.every(axis => of.includes(axis)) && of.length > than.length\n}\n\n/**\n * Pick one. Nothing fits → nothing is drawn, and the caller says so rather than showing a default.\n *\n * A screen that appears when nothing was assigned teaches the factory that assignment does not\n * matter, and then nobody trusts what they see.\n */\nexport function chooseStationAssignment(rules: readonly StationAssignmentRule[], situation: StationAssignmentSituation): StationAssignmentChoice | undefined {\n  const candidates = rules.filter(rule => fits(rule, situation))\n\n  if (!candidates.length) {\n    return undefined\n  }\n\n  const withAxes = candidates.map(rule => ({ rule, axes: constrainedAxes(rule) }))\n\n  /* Drop anything another candidate says strictly more than. */\n  const finalists = withAxes.filter(one => !withAxes.some(other => isSuperset(other.axes, one.axes)))\n\n  const best = finalists.reduce((winner, one) => {\n    const byPriority = (one.rule.priority ?? 0) - (winner.rule.priority ?? 0)\n\n    if (byPriority !== 0) {\n      return byPriority > 0 ? one : winner\n    }\n\n    /* Same priority, neither more specific. Pick by name so the same factory sees the same screen. */\n    return one.rule.name < winner.rule.name ? one : winner\n  })\n\n  const tied = finalists.filter(one => one.rule !== best.rule && (one.rule.priority ?? 0) === (best.rule.priority ?? 0))\n\n  return {\n    name: best.rule.name,\n    boardId: best.rule.boardId,\n    matchedOn: best.axes,\n    ambiguousWith: tied.map(one => one.rule.name).sort()\n  }\n}\n"]}