@things-factory/worklist 10.1.39 → 10.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.39",
+  "version": "10.1.41",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -37,14 +37,14 @@
     "@operato/moment-timezone-es": "^10.0.0",
     "@operato/p13n": "^10.0.0",
     "@operato/popup": "^10.15.0",
-    "@things-factory/attachment-base": "^10.1.39",
-    "@things-factory/auth-base": "^10.1.39",
-    "@things-factory/board-service": "^10.1.39",
-    "@things-factory/context-ui": "^10.1.39",
-    "@things-factory/organization": "^10.1.39",
-    "@things-factory/personalization": "^10.1.39",
-    "@things-factory/scheduler-client": "^10.1.39",
-    "@things-factory/shell": "^10.1.39"
+    "@things-factory/attachment-base": "^10.1.40",
+    "@things-factory/auth-base": "^10.1.40",
+    "@things-factory/board-service": "^10.1.41",
+    "@things-factory/context-ui": "^10.1.40",
+    "@things-factory/organization": "^10.1.40",
+    "@things-factory/personalization": "^10.1.40",
+    "@things-factory/scheduler-client": "^10.1.40",
+    "@things-factory/shell": "^10.1.40"
   },
-  "gitHead": "fe5257ad8995fe7e79275e287f36e95b5fd32d1c"
+  "gitHead": "4f41243edca4c965bc6992a10fb52d75a58fd3a9"
 }

package/tests/work-door-door-words.test.ts

@@ -2,7 +2,18 @@ import assert from 'node:assert/strict'
 import { readFileSync } from 'node:fs'
 import { join } from 'node:path'
 
-import { DOOR_KIND_WORD, DOOR_STANDING_WORD, kindWord, standingWord } from '../client/pages/work-door/door-words.js'
+import {
+  DOOR_KIND_WORD,
+  DOOR_REASON_WORD,
+  DOOR_STANDING_WORD,
+  WHEN_NO_LINE_BECAUSE_WORD,
+  WHEN_NO_LINE_WORD,
+  kindWord,
+  reasonWord,
+  standingWord,
+  whenNoLineBecauseWord,
+  whenNoLineWord
+} from '../client/pages/work-door/door-words.js'
 
 /*
  * ═══════════════════════════════════════════════════════════════════════════
@@ -53,6 +64,29 @@ test('every kind the server can send has a word here', () => {
   }
 })
 
+/*
+ * The three enums the row's sentence is built from travel the same way. A reason the screen cannot
+ * read picks no sentence; an empty-line declaration it cannot read falls back to saying nothing about
+ * the consequence - the very sentence this row got wrong before.
+ */
+test('every reason and empty-line declaration the server can send has a word here, and nothing extra', () => {
+  for (const [name, read, table] of [
+    ['DoorReasonValue', reasonWord, DOOR_REASON_WORD],
+    ['WhenNoLineValue', whenNoLineWord, WHEN_NO_LINE_WORD],
+    ['WhenNoLineBecauseValue', whenNoLineBecauseWord, WHEN_NO_LINE_BECAUSE_WORD]
+  ] as const) {
+    const declared = members(name)
+
+    assert.ok(declared.length >= 3, `${name} 를 ${declared.length}개만 읽었습니다`)
+
+    for (const [wire, value] of declared) {
+      assert.equal(read(wire), value, `${name}.${wire} 이 전선으로 오면 화면이 못 읽습니다`)
+    }
+
+    assert.deepEqual(Object.keys(table).filter(one => !declared.some(([wire]) => wire === one)), [])
+  }
+})
+
 test('nothing extra is mapped — a dead entry hides that the server dropped a value', () => {
   const standings = new Set(members('DoorStandingValue').map(one => one[0]))
   const kinds = new Set(members('DoorKindValue').map(one => one[0]))

package/tests/work-door-not-used-refuse.test.ts

@@ -25,14 +25,14 @@ const { Domain, addDataSource, removeDataSource } = require('@things-factory/she
 const { User } = require('@things-factory/auth-base')
 
 const REFUSING = [
-  { name: 'Scrap', labelKey: 'x', kind: 'approval', whenNoLine: 'refuse', because: 'irreversible' },
-  { name: 'Release', labelKey: 'x', kind: 'approval', whenNoLine: 'refuse', because: 'approval-is-the-act' },
-  { name: 'Defer', labelKey: 'x', kind: 'approval', whenNoLine: 'refuse', because: 'lowers-a-control' }
+  { name: 'Scrap', kind: 'approval', whenNoLine: 'refuse', because: 'irreversible' },
+  { name: 'Release', kind: 'approval', whenNoLine: 'refuse', because: 'approval-is-the-act' },
+  { name: 'Defer', kind: 'approval', whenNoLine: 'refuse', because: 'lowers-a-control' }
 ]
 const ACCEPTED = [
-  { name: 'Priority', labelKey: 'x', kind: 'approval', whenNoLine: 'run' },
-  { name: 'Withdraw', labelKey: 'x', kind: 'approval', whenNoLine: 'as-established', because: 'approval-is-the-act' },
-  { name: 'Dispatch', labelKey: 'x', kind: 'assignment' }
+  { name: 'Priority', kind: 'approval', whenNoLine: 'run' },
+  { name: 'Withdraw', kind: 'approval', whenNoLine: 'as-established', because: 'approval-is-the-act' },
+  { name: 'Dispatch', kind: 'assignment' }
 ]
 
 let db: any

package/tests/work-door-sentence.test.ts

@@ -0,0 +1,199 @@
+import { strict as assert } from 'node:assert'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import {
+  DoorFacts,
+  doorLabel,
+  doorSentence,
+  doorsSummary,
+  whenNoLineTag
+} from '../client/pages/work-door/door-sentence.js'
+import { DOOR_REASON_WORD, WHEN_NO_LINE_BECAUSE_WORD, WHEN_NO_LINE_WORD } from '../client/pages/work-door/door-words.js'
+
+/*
+ * ═══════════════════════════════════════════════════════════════════════════
+ * The work-doors screen writes its own sentences from the facts the server sends. These read them
+ * through the real translation files, so a missing key or a sentence that says the wrong
+ * consequence shows here and not on a customer's screen.
+ *
+ * The consequence of an empty line is the door's declaration. On :4000 (2026-09-24) four doors that
+ * refuse an empty line - spec, recipe, material definition and work shift change approvals - read
+ * "the raiser approves their own the moment they raise it". That was the `run` sentence on every door.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+const LANGS = ['ko', 'en', 'ja', 'zh', 'ms'] as const
+
+const said = Object.fromEntries(
+  LANGS.map(lang => [
+    lang,
+    JSON.parse(readFileSync(join(__dirname, '..', 'translations', `${lang}.json`), 'utf-8')) as Record<string, string>
+  ])
+) as Record<(typeof LANGS)[number], Record<string, string>>
+
+/** A small `t` over one language: key lookup, `{name}` interpolation, `defaultValue`. Missing keys print themselves, as i18next does. */
+function tIn(lang: (typeof LANGS)[number], extra: Record<string, string> = {}) {
+  const table = { ...said[lang], ...extra }
+
+  return (key: string, options: Record<string, any> = {}) => {
+    const found = table[key] ?? options.defaultValue ?? key
+
+    return String(found).replace(/\{(\w+)\}/g, (_, name) => (name in options ? String(options[name]) : `{${name}}`))
+  }
+}
+
+const ko = tIn('ko', {
+  'activity.material-definition-change-approval.label': '자재 정의 변경 승인',
+  'activity.work-order-priority-change.label': '작업지시 우선순위 변경',
+  'activity.station-screen-release.label': '화면 발행 승인'
+})
+
+const door = (over: Partial<DoorFacts>): DoorFacts => ({
+  name: 'MaterialDefinitionChangeApproval',
+  labelKey: 'activity.material-definition-change-approval.label',
+  kind: 'approval',
+  standing: 'off',
+  reason: 'line-empty',
+  approvers: 0,
+  ...over
+})
+
+describe('work door sentences', () => {
+  it('tells a refusing door it cannot be raised, and why - never that the raiser approves their own', () => {
+    const sentence = doorSentence(ko, door({ whenNoLine: 'refuse', whenNoLineBecause: 'approval-is-the-act' }))
+
+    assert.ok(sentence.includes('「자재 정의 변경 승인」 에 결재자가 없습니다'), sentence)
+    assert.ok(sentence.includes('올릴 수 없습니다'), sentence)
+    assert.ok(sentence.includes('승인 자체가 이 업무의 일'), sentence)
+    assert.ok(!sentence.includes('자기 건을 승인'), sentence)
+  })
+
+  it('keeps the self-approval sentence for a door that runs on an empty line', () => {
+    const sentence = doorSentence(
+      ko,
+      door({ name: 'WorkOrderPriorityChange', labelKey: 'activity.work-order-priority-change.label', whenNoLine: 'run' })
+    )
+
+    assert.equal(
+      sentence,
+      '「작업지시 우선순위 변경」 에 결재자가 없습니다. 이 단계는 서지 않고, 올린 사람이 올리는 순간 자기 건을 승인한 것이 됩니다.'
+    )
+  })
+
+  it('says a door that follows its history depends on how the record stood', () => {
+    const sentence = doorSentence(ko, door({ whenNoLine: 'as-established', whenNoLineBecause: 'approval-is-the-act' }))
+
+    assert.ok(sentence.includes('결재를 거쳐 선 건은'), sentence)
+    assert.ok(!sentence.includes('자기 건을 승인'), sentence)
+  })
+
+  /** A door with no declaration says only what is known - it does not guess a consequence. */
+  it('names no consequence for an undeclared door', () => {
+    assert.equal(doorSentence(ko, door({})), '「자재 정의 변경 승인」 에 결재자가 없습니다.')
+  })
+
+  it('says where the line is set when a door follows another door', () => {
+    const sentence = doorSentence(ko, door({ followsLabelKey: 'activity.station-screen-release.label', whenNoLine: 'run' }))
+
+    assert.ok(sentence.includes('「화면 발행 승인」 의 결재선을 따르므로'), sentence)
+  })
+
+  it('shows the empty-line declaration on a filled row, with the reason for a refusing door', () => {
+    const tag = whenNoLineTag(
+      ko,
+      door({ standing: 'on', reason: 'line-filled', approvers: 1, whenNoLine: 'refuse', whenNoLineBecause: 'irreversible' })
+    )
+
+    assert.equal(tag, '결재선이 비면 올릴 수 없습니다 (되돌릴 수 없는 일)')
+    /* An empty row's sentence already says it; saying it twice is noise. */
+    assert.equal(whenNoLineTag(ko, door({ whenNoLine: 'refuse', whenNoLineBecause: 'irreversible' })), '')
+    assert.equal(whenNoLineTag(ko, door({ kind: 'assignment', standing: 'on', reason: 'assignee-bound' })), '')
+  })
+
+  it('keeps the other rows in their Korean wording', () => {
+    assert.ok(doorSentence(ko, door({ reason: 'role-empty' })).includes('역할에 사람이 없습니다'))
+    assert.ok(doorSentence(ko, door({ reason: 'person-absent' })).includes('지목한 사람이 이 공장에 없습니다'))
+    assert.ok(doorSentence(ko, door({ kind: 'assignment', reason: 'no-assignee' })).includes('아무에게도 가지 않습니다'))
+    assert.ok(
+      doorSentence(ko, door({ kind: 'assignment', standing: 'on', reason: 'assignee-bound', assigneeRole: 'MAINTENANCE-LEAD' })).includes(
+        'MAINTENANCE-LEAD'
+      )
+    )
+    assert.ok(doorSentence(ko, door({ standing: 'on', reason: 'line-filled', approvers: 2 })).includes('결재자 2명'))
+    assert.ok(doorSentence(ko, door({ standing: 'missing', reason: 'missing' })).includes('세우지 못한 것'))
+    assert.ok(
+      doorSentence(ko, door({ standing: 'not-used', reason: 'not-used', notUsedBecause: '폐기는 본사가 처리합니다' })).includes(
+        '폐기는 본사가 처리합니다'
+      )
+    )
+  })
+
+  /** A label with no translation shows the form name, which a person can search for - not the key. */
+  it('falls back to the form name, never the key', () => {
+    assert.equal(doorLabel(tIn('ko'), { name: 'SomeDoor', labelKey: 'activity.some-door.label' }), 'SomeDoor')
+  })
+
+  /*
+   * Every sentence this screen can build, in every language shipped. A missing one prints its key on
+   * the screen and nothing throws.
+   */
+  it('has every sentence it can build, in every language', () => {
+    const keys = [
+      ...Object.values(DOOR_REASON_WORD)
+        .filter(reason => reason !== 'line-empty')
+        .map(reason => `text.door-because-${reason}`),
+      'text.door-because-line-empty',
+      ...Object.values(WHEN_NO_LINE_WORD).map(when => `text.door-because-line-empty-${when}`),
+      ...Object.values(WHEN_NO_LINE_WORD).map(when => `text.door-when-no-line-${when}`),
+      ...Object.values(WHEN_NO_LINE_BECAUSE_WORD).map(why => `text.door-refuses-because-${why}`),
+      'text.door-because-follows',
+      ...['none', 'all-on', 'done-not-used', 'todo', 'off', 'missing', 'not-used'].map(
+        one => `text.work-doors-summary-${one}`
+      )
+    ]
+    const missing = LANGS.flatMap(lang => keys.filter(key => !said[lang][key]).map(key => `${lang} · ${key}`))
+
+    assert.deepEqual(missing, [], `\n없는 문구는 화면에 키 글자로 뜹니다:\n${missing.join('\n')}`)
+  })
+
+  it('reads English to an English reader', () => {
+    const sentence = doorSentence(tIn('en'), door({ whenNoLine: 'refuse', whenNoLineBecause: 'irreversible' }))
+
+    assert.ok(sentence.includes('cannot be raised until its approval line is filled'), sentence)
+    assert.ok(!/[가-힣]/.test(sentence), sentence)
+  })
+})
+
+describe('work door summary', () => {
+  const counts = (over: object) => ({ on: 0, off: 0, missing: 0, notUsed: 0, todo: 0, ...over })
+
+  it('says everything stands when it does', () => {
+    const summary = doorsSummary(ko, counts({ on: 2 }))
+
+    assert.equal(summary, '업무 문 2개가 다 서 있습니다.')
+  })
+
+  it('reads as done when the only unfilled ones were opted out', () => {
+    const summary = doorsSummary(ko, counts({ on: 1, notUsed: 1 }))
+
+    assert.ok(summary.includes('채울 것이 남지 않았습니다'))
+    assert.ok(summary.includes('1개는 이 공장이 쓰지 않기로'))
+  })
+
+  it('leads with how many are left to fill', () => {
+    const summary = doorsSummary(ko, counts({ on: 1, off: 2, notUsed: 1, todo: 2 }))
+
+    assert.ok(summary.startsWith('채울 것이 2개 남았습니다.'))
+    assert.ok(summary.includes('1개는 이 공장이 쓰지 않기로 한 것이라 세지 않았습니다'))
+  })
+
+  it('names a door that never installed as a defect', () => {
+    assert.ok(doorsSummary(ko, counts({ on: 1, missing: 1, todo: 1 })).includes('설정이 아니라 결함'))
+  })
+
+  /** Zero doors is a different fact from "none of them stand" and must not be reported as it. */
+  it('does not report an empty product as a plant with nothing standing', () => {
+    assert.equal(doorsSummary(ko, counts({})), '이 제품이 세우는 업무 양식이 없습니다.')
+  })
+})

package/tests/work-door.test.ts

@@ -1,14 +1,14 @@
 import { strict as assert } from 'node:assert'
 
-import { doorsToFill, judgeDoor, summarizeDoors } from '../server/service/work-door/work-door.js'
+import { countDoors, doorsToFill, judgeDoor } from '../server/service/work-door/work-door.js'
 
 /**
  * An empty line is a choice, not a defect — but nothing said which doors were in that state.
  * Miratek had all eleven installed and all eleven empty (measured 2026-09-11), so corrections,
  * scrapping and dispositions all took effect there with nobody approving.
  */
-const approval = (label: string, over: object = {}) => ({ name: 'x', label, kind: 'approval' as const, ...over })
-const assignment = (label: string, over: object = {}) => ({ name: 'x', label, kind: 'assignment' as const, ...over })
+const approval = (name: string, over: object = {}) => ({ name, kind: 'approval' as const, whenNoLine: 'run' as const, ...over })
+const assignment = (name: string, over: object = {}) => ({ name, kind: 'assignment' as const, ...over })
 
 describe('work door standing', () => {
   /**
@@ -17,24 +17,24 @@ describe('work door standing', () => {
    */
   it('says where the line is set when a door follows another door', () => {
     const standing = judgeDoor(
-      approval('통제 해제 승인', {
-        follows: '화면 발행 승인',
+      approval('StationScreenControlWithdrawal', {
+        follows: 'StationScreenRelease',
         installed: { approvalLine: [{}] },
         approvalStanding: { approvers: 1 }
       })
     )
     const empty = judgeDoor(
-      approval('통제 해제 승인', {
-        follows: '화면 발행 승인',
+      approval('StationScreenControlWithdrawal', {
+        follows: 'StationScreenRelease',
         installed: {},
         approvalStanding: { approvers: 0, refusal: { code: 'approval-line-missing' } }
       })
     )
 
     assert.equal(standing.standing, 'on')
-    assert.ok(standing.because.includes('「화면 발행 승인」 의 결재선을 따르므로'))
+    assert.equal(standing.followsLabelKey, 'activity.station-screen-release.label')
     assert.equal(empty.standing, 'off')
-    assert.ok(empty.because.includes('「화면 발행 승인」 의 결재선을 따르므로'), empty.because)
+    assert.equal(empty.followsLabelKey, 'activity.station-screen-release.label')
   })
 
   it('reads a filled approval line as standing, and says how many it passes', () => {
@@ -47,7 +47,7 @@ describe('work door standing', () => {
 
     assert.equal(door.standing, 'on')
     assert.equal(door.approvers, 2)
-    assert.ok(door.because.includes('결재자 2명'))
+    assert.equal(door.reason, 'line-filled')
   })
 
   /**
@@ -80,8 +80,7 @@ describe('work door standing', () => {
 
     assert.equal(door.standing, 'off')
     assert.equal(door.approvers, 0)
-    assert.ok(door.because.includes('역할에 사람이 없습니다'))
-    assert.ok(!door.because.includes('자기 건을 승인한'))
+    assert.equal(door.reason, 'role-empty')
   })
 
   /** A named person who is not here is the same defect on the other axis (ADR-0047 ③). */
@@ -94,8 +93,7 @@ describe('work door standing', () => {
     )
 
     assert.equal(door.standing, 'off')
-    assert.ok(door.because.includes('지목한 사람이 이 공장에 없습니다'))
-    assert.ok(!door.because.includes('자기 건을 승인한'))
+    assert.equal(door.reason, 'person-absent')
   })
 
   /** Not having read the line must not read as "the line is filled". */
@@ -106,14 +104,49 @@ describe('work door standing', () => {
   })
 
   /**
-   * Worklist completes the instance on issue when the line is empty, so the person raising it has
-   * approved their own. "No approval happens" would be the wrong thing to tell an administrator.
+   * What an empty line does is the door's own declaration (ADR-0077 decision 1). The judge used to
+   * write "the raiser approves their own" for every door, and four refusing doors on :4000 carried it
+   * (2026-09-24). The declaration now travels with the row, so the screen can say which it is.
    */
-  it('says an empty approval line means the raiser approves their own', () => {
-    const door = judgeDoor(approval('폐기 실행 승인', { installed: { approvalLine: [] } }))
+  it('carries the door\'s own empty-line declaration, and its reason', () => {
+    const run = judgeDoor(approval('WorkOrderPriorityChange', { installed: { approvalLine: [] } }))
+    const refuse = judgeDoor(
+      approval('ScrapExecution', { whenNoLine: 'refuse', whenNoLineBecause: 'irreversible', installed: { approvalLine: [] } })
+    )
+    const established = judgeDoor(
+      approval('NonWorkingWithdrawal', {
+        whenNoLine: 'as-established',
+        whenNoLineBecause: 'approval-is-the-act',
+        installed: { approvalLine: [] }
+      })
+    )
 
-    assert.equal(door.standing, 'off')
-    assert.ok(door.because.includes('자기 건을 승인한'))
+    assert.deepEqual([run.reason, run.whenNoLine, run.whenNoLineBecause], ['line-empty', 'run', undefined])
+    assert.deepEqual([refuse.reason, refuse.whenNoLine, refuse.whenNoLineBecause], ['line-empty', 'refuse', 'irreversible'])
+    assert.deepEqual(
+      [established.whenNoLine, established.whenNoLineBecause],
+      ['as-established', 'approval-is-the-act']
+    )
+  })
+
+  /** An assignment door has no approval line, so it carries no empty-line declaration either. */
+  it('carries no empty-line declaration on an assignment door', () => {
+    const door = judgeDoor(assignment('WorkOrderDispatch', { whenNoLine: 'run', installed: {} }))
+
+    assert.equal(door.whenNoLine, undefined)
+  })
+
+  /**
+   * The label key is computed from the name - never declared. plant declared
+   * `activity.MaterialDefinitionChangeApproval.label` while its translations are kebab-cased, and the
+   * screen printed twenty-four raw keys (:4000, 2026-09-24).
+   */
+  it('computes the label key from the name, the same key the activity catalog reads', () => {
+    assert.equal(
+      judgeDoor(approval('MaterialDefinitionChangeApproval')).labelKey,
+      'activity.material-definition-change-approval.label'
+    )
+    assert.equal(judgeDoor(approval('WMS Order Recall')).labelKey, 'activity.wms-order-recall.label')
   })
 
   /**
@@ -124,15 +157,15 @@ describe('work door standing', () => {
     const door = judgeDoor(assignment('작업 지시 배정', { installed: { assigneeRole: undefined } }))
 
     assert.equal(door.standing, 'off')
-    assert.ok(door.because.includes('아무에게도 가지 않습니다'))
-    assert.ok(!door.because.includes('자기 건을 승인'))
+    assert.equal(door.reason, 'no-assignee')
   })
 
   it('reads a bound role as standing and names it', () => {
     const door = judgeDoor(assignment('정비 배정', { installed: { assigneeRole: 'MAINTENANCE-LEAD' } }))
 
     assert.equal(door.standing, 'on')
-    assert.ok(door.because.includes('MAINTENANCE-LEAD'))
+    assert.equal(door.reason, 'assignee-bound')
+    assert.equal(door.assigneeRole, 'MAINTENANCE-LEAD')
   })
 
   /** An approval line on an assignment door is not what fills it, and must not read as standing. */
@@ -149,7 +182,7 @@ describe('work door standing', () => {
     const door = judgeDoor(approval('초품 검사 승인'))
 
     assert.equal(door.standing, 'missing')
-    assert.ok(door.because.includes('세우지 못한 것'))
+    assert.equal(door.reason, 'missing')
   })
 
   describe('a plant that says it does not use one', () => {
@@ -161,7 +194,7 @@ describe('work door standing', () => {
       const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '폐기는 본사가 처리합니다' }))
 
       assert.equal(door.standing, 'not-used')
-      assert.ok(door.because.includes('폐기는 본사가 처리합니다'))
+      assert.equal(door.notUsedBecause, '폐기는 본사가 처리합니다')
     })
 
     /** Said first, or a plant that opted out keeps being told its missing form is a defect. */
@@ -169,7 +202,7 @@ describe('work door standing', () => {
       const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '안 씁니다', installed: undefined }))
 
       assert.equal(door.standing, 'not-used')
-      assert.ok(!door.because.includes('결함'))
+      assert.equal(door.reason, 'not-used')
     })
 
     it('is never counted as something to fill', () => {
@@ -183,40 +216,14 @@ describe('work door standing', () => {
   })
 })
 
-describe('summary', () => {
+describe('counts', () => {
   const on = judgeDoor(approval('A', { installed: { approvalLine: [{}] }, approvalStanding: { approvers: 1 } }))
   const off = judgeDoor(approval('B', { installed: { approvalLine: [] } }))
   const missing = judgeDoor(approval('C'))
   const notUsed = judgeDoor(approval('D', { notUsedBecause: '안 씁니다' }))
 
-  it('says everything stands when it does', () => {
-    const said = summarizeDoors([on, on])
-
-    assert.ok(said.includes('2개가 다 서 있습니다'))
-    assert.ok(!said.includes('결함'))
-  })
-
-  /** Zero left to fill has to read as done even when some doors were opted out. */
-  it('reads as done when the only unfilled ones were opted out', () => {
-    const said = summarizeDoors([on, notUsed])
-
-    assert.ok(said.includes('채울 것이 남지 않았습니다'))
-    assert.ok(said.includes('1개는 이 공장이 쓰지 않기로'))
-  })
-
-  it('leads with how many are left to fill', () => {
-    const said = summarizeDoors([on, off, off, notUsed])
-
-    assert.ok(said.startsWith('채울 것이 2개 남았습니다.'))
-    assert.ok(said.includes('1개는 이 공장이 쓰지 않기로 한 것이라 세지 않았습니다'))
-  })
-
-  it('names a door that never installed as a defect', () => {
-    assert.ok(summarizeDoors([on, missing]).includes('설정이 아니라 결함'))
-  })
-
-  /** Zero doors is a different fact from "none of them stand" and must not be reported as it. */
-  it('does not report an empty product as a plant with nothing standing', () => {
-    assert.equal(summarizeDoors([]), '이 제품이 세우는 업무 양식이 없습니다.')
+  it('counts each standing apart, so the screen can say the plant in one sentence', () => {
+    assert.deepEqual(countDoors([on, off, off, missing, notUsed]), { on: 1, off: 2, missing: 1, notUsed: 1 })
+    assert.deepEqual(countDoors([]), { on: 0, off: 0, missing: 0, notUsed: 0 })
   })
 })

package/translations/en.json

@@ -226,6 +226,24 @@
   "menu.work-doors": "approval and assignment forms",
   "text.discard-draft-confirm": "discard this draft?",
   "text.discard-draft-for-good": "a discarded draft cannot be brought back.",
+  "text.door-because-assignee-bound": "\"{label}\" goes to {role}.",
+  "text.door-because-follows": "it follows the approval line of \"{label}\", so the line is set there.",
+  "text.door-because-line-empty": "\"{label}\" has no approvers.",
+  "text.door-because-line-empty-as-established": "\"{label}\" has no approvers. a record that stood through approval cannot be raised until the line is filled; one that stood without approval takes effect as soon as it is raised.",
+  "text.door-because-line-empty-refuse": "\"{label}\" has no approvers. this task cannot be raised until its approval line is filled ({why}).",
+  "text.door-because-line-empty-run": "\"{label}\" has no approvers. the step does not stand, and whoever raises it approves their own the moment they raise it.",
+  "text.door-because-line-filled": "\"{label}\" passes {count} approvers.",
+  "text.door-because-missing": "the \"{label}\" form was not installed in this plant. the plant did not opt out; it failed to install, so check the startup log.",
+  "text.door-because-no-assignee": "no role is bound to receive \"{label}\". the task is created but reaches nobody.",
+  "text.door-because-not-used": "\"{label}\" is a task this plant decided not to use — {reason}",
+  "text.door-because-person-absent": "the person named in the approval line of \"{label}\" is not in this plant. name someone else or add that person for this step to stand.",
+  "text.door-because-role-empty": "the role named in the approval line of \"{label}\" has nobody in it. the line is set; put a person in that role for this step to stand.",
+  "text.door-refuses-because-approval-is-the-act": "the approval is the work itself",
+  "text.door-refuses-because-irreversible": "what it does cannot be undone",
+  "text.door-refuses-because-lowers-a-control": "it lowers a control that stands",
+  "text.door-when-no-line-as-established": "with no approval line, it depends on how the record stood",
+  "text.door-when-no-line-refuse": "with no approval line, it cannot be raised",
+  "text.door-when-no-line-run": "with no approval line, it takes effect as soon as it is raised",
   "text.draft-discarded": "the draft was discarded.",
   "text.activity-activated": "{name} is now on for this domain.",
   "text.activity-change-failed": "{name} was not changed: {why}",
@@ -322,10 +340,17 @@
   "text.task_is_saved_successfully": "task is saved successfully",
   "text.task_is_started_successfully": "task is started successfully.",
   "text.timeline-count": "{count} entries",
-  "text.work-doors-lead": "shows whether each approval and assignment step has approvers or receivers. without them, an approval completes as soon as it is raised and an assignment reaches nobody.",
+  "text.work-doors-lead": "shows whether each approval and assignment step has approvers or receivers. without approvers, an approval either takes effect as soon as it is raised or cannot be raised at all, depending on the task; an assignment reaches nobody.",
   "text.work-doors-next-line": "set an approval line on {count} work forms —",
   "text.work-doors-next-seats": "{standing} of {offered} roles are set up. set up roles first to use them in approval lines —",
   "text.work-doors-read-failed": "could not read the approval forms.",
+  "text.work-doors-summary-all-on": "all {count} work forms are set.",
+  "text.work-doors-summary-done-not-used": "nothing left to fill. {on} work forms are set and {notUsed} are ones this plant decided not to use.",
+  "text.work-doors-summary-missing": "{count} were never installed. that is a defect, not a setting.",
+  "text.work-doors-summary-none": "this product installs no work forms.",
+  "text.work-doors-summary-not-used": "{count} this plant decided not to use are not counted.",
+  "text.work-doors-summary-off": "{count} are installed with nobody on them — this plant has not yet decided who does them.",
+  "text.work-doors-summary-todo": "forms left to fill: {count}.",
   "text.write-your-comment-as-reference": "write your comment.",
   "title.activity": "activity",
   "title.activity application": "activity application",

package/translations/ja.json

@@ -226,6 +226,24 @@
   "menu.work-doors": "承認・割当様式の状況",
   "text.discard-draft-confirm": "この下書きを破棄しますか？",
   "text.discard-draft-for-good": "破棄した下書きは元に戻せません。",
+  "text.door-because-assignee-bound": "「{label}」 は {role} が受け取ります。",
+  "text.door-because-follows": "「{label}」 の承認ルートに従うため、承認ルートはそちらで設定します。",
+  "text.door-because-line-empty": "「{label}」 に承認者がいません。",
+  "text.door-because-line-empty-as-established": "「{label}」 に承認者がいません。承認を経て成立した件は承認ルートを設定するまで起票できず、承認なしで成立した件は起票した時点で反映されます。",
+  "text.door-because-line-empty-refuse": "「{label}」 に承認者がいません。承認ルートを設定するまでこの業務は起票できません({why})。",
+  "text.door-because-line-empty-run": "「{label}」 に承認者がいません。この段階は成立せず、起票した人が起票した時点で自分の件を承認したことになります。",
+  "text.door-because-line-filled": "「{label}」 は承認者 {count}名を経ます。",
+  "text.door-because-missing": "「{label}」 の様式がこの工場に設置されていません。工場が使わないと決めたのではなく設置できなかったものなので、起動記録を確認してください。",
+  "text.door-because-no-assignee": "「{label}」 を受け取るロールが割り当てられていません。この業務は作成されても誰にも届きません。",
+  "text.door-because-not-used": "「{label}」 はこの工場が使わないと決めた業務です — {reason}",
+  "text.door-because-person-absent": "「{label}」 の承認ルートが指定した人がこの工場にいません。別の人を指定するか、その人を追加するとこの段階が成立します。",
+  "text.door-because-role-empty": "「{label}」 の承認ルートが指定したロールに人がいません。承認ルートは決まっているので、そのロールに人を入れるとこの段階が成立します。",
+  "text.door-refuses-because-approval-is-the-act": "承認そのものがこの業務",
+  "text.door-refuses-because-irreversible": "取り消せない作業",
+  "text.door-refuses-because-lowers-a-control": "かかっている統制を下げる作業",
+  "text.door-when-no-line-as-established": "承認ルートが空ならその件がどう成立したかによります",
+  "text.door-when-no-line-refuse": "承認ルートが空なら起票できません",
+  "text.door-when-no-line-run": "承認ルートが空なら起票した時点で反映されます",
   "text.draft-discarded": "下書きを破棄しました。",
   "text.activity-activated": "{name} をこの$t(term.domain)で使用するようにしました。",
   "text.activity-change-failed": "{name} を変更できませんでした: {why}",
@@ -322,10 +340,17 @@
   "text.task_is_saved_successfully": "業務が正常に保存されました。",
   "text.task_is_started_successfully": "業務が正常に開始されました。",
   "text.timeline-count": "{count}件",
-  "text.work-doors-lead": "承認・割当の各段階で承認者と受取人が決まっているかを表示します。決めていないと、承認は申請と同時に承認され、割当は誰にも届きません。",
+  "text.work-doors-lead": "承認・割当の各段階で承認者と受取人が決まっているかを表示します。承認者がいないと、承認は業務によって起票と同時に反映されるか起票できなくなり、割当は誰にも届きません。",
   "text.work-doors-next-line": "業務様式 {count}件に承認ラインを指定してください —",
   "text.work-doors-next-seats": "ロール {offered}件中 {standing}件が設定されています。承認ラインに使うロールを先に設定してください —",
   "text.work-doors-read-failed": "承認様式の状況を読み込めませんでした。",
+  "text.work-doors-summary-all-on": "業務様式 {count}件がすべて設定されています。",
+  "text.work-doors-summary-done-not-used": "設定すべきものは残っていません。業務様式 {on}件が設定済みで、{notUsed}件はこの工場が使わないと決めたものです。",
+  "text.work-doors-summary-missing": "{count}件は様式がまったく設置されていません。これは設定ではなく欠陥です。",
+  "text.work-doors-summary-none": "この製品が設置する業務様式はありません。",
+  "text.work-doors-summary-not-used": "{count}件はこの工場が使わないと決めたものなので数えていません。",
+  "text.work-doors-summary-off": "{count}件は様式はあるが担当者がいません — 誰が行うかをこの工場がまだ決めていないものです。",
+  "text.work-doors-summary-todo": "設定すべきものが {count}件 残っています。",
   "text.write-your-comment-as-reference": "ご意見をご記入ください。",
   "title.activity": "業務",
   "title.activity application": "業務申込書作成",