@things-factory/worklist 10.1.31 → 10.1.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/worklist",
-  "version": "10.1.31",
+  "version": "10.1.32",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -41,10 +41,10 @@
     "@things-factory/auth-base": "^10.1.31",
     "@things-factory/board-service": "^10.1.31",
     "@things-factory/context-ui": "^10.1.31",
-    "@things-factory/organization": "^10.1.31",
+    "@things-factory/organization": "^10.1.32",
     "@things-factory/personalization": "^10.1.31",
     "@things-factory/scheduler-client": "^10.1.31",
     "@things-factory/shell": "^10.1.31"
   },
-  "gitHead": "5213e6f9913b40ea2618a2111d9884b792dbaa01"
+  "gitHead": "67b211e001da3a923e562cb048e4691bd961315c"
 }

package/tests/screen-seam.test.ts

@@ -0,0 +1,50 @@
+/**
+ * A screen this module routes to is a screen the shell can actually build.
+ *
+ * ── How this fails, and why nothing says so ───────────────────────────────
+ * Three things have to agree for a page to open: `client/route.ts` maps the page name to an import,
+ * the element registers itself as a custom element, and `things-factory.config.js` carries a
+ * `{ tagname, page }` pair. The shell builds the element from **that pair**. With the first two and
+ * not the third, the route resolves, the element is defined, and the shell puts nothing in the DOM:
+ * a blank screen, no console error, nothing in the server log.
+ *
+ * operato-plant met this twice (2026-09-03 and 2026-09-15; its own config carries a comment saying
+ * so), and the work-door screens met it a third time on the way into this module - the page and its
+ * route came across and the pair did not. Warehouse found it by opening the screen.
+ *
+ * So the agreement is counted here rather than trusted: the config file is data and route.ts names
+ * its cases in plain text, and nobody has to remember the third place.
+ */
+
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const root = join(__dirname, '..')
+
+/** The page names `route()` answers to, read as text - importing it would pull the whole client in. */
+function routedPages(): string[] {
+  const source = readFileSync(join(root, 'client', 'route.ts'), 'utf-8')
+
+  return [...source.matchAll(/case '([^']+)':/g)].map(match => match[1])
+}
+
+/** The pages the shell can build, from the module's declaration. */
+function pagesWithATagname(): string[] {
+  const config = readFileSync(join(root, 'things-factory.config.js'), 'utf-8')
+
+  return [...config.matchAll(/\{\s*tagname:\s*'[^']+',\s*page:\s*'([^']+)'\s*\}/g)].map(match => match[1])
+}
+
+describe('a routed screen can be built', () => {
+  it('reads both sides - an empty reading would let everything pass', () => {
+    expect(routedPages().length).toBeGreaterThanOrEqual(10)
+    expect(pagesWithATagname().length).toBeGreaterThanOrEqual(10)
+  })
+
+  it('★ every page this module routes to has a tagname the shell can build', () => {
+    const buildable = new Set(pagesWithATagname())
+    const blank = routedPages().filter(page => !buildable.has(page))
+
+    expect(blank).toEqual([])
+  })
+})

package/tests/work-door-approval-line-standing.test.ts

@@ -0,0 +1,117 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { judgeApprovalLine, rolesNamedIn } from '../server/service/work-door/approval-line-standing.js'
+
+const role = (value: string, participation?: string) => ({ type: 'Role', value, participation })
+
+/**
+ * 자리를 사람으로 풀어 주는 포트. 이 판단은 DB 를 모르므로 시험도 DB 없이 선다.
+ *
+ * ⚠ `approval-role-empty` 와 `approval-person-absent` 는 **실 자료로 걸어 본 적이 없다.** 역할을
+ * 지목했는데 그 역할이 빈 결재선도, 없는 사람을 지목한 결재선도 지금 어느 테넌트에도 없다 —
+ * 미라텍은 역할이 0이라 결재선을 만들 재료가 없고, system 은 역할마다 사람이 있다. 여기가 그 둘을
+ * 잡는 유일한 자리다.
+ */
+const peopleIn = (...ids: string[]) => ({
+  roleHasMembers: async (roleId: string) => ids.includes(roleId),
+  personIsHere: async (personId: string) => ids.includes(personId)
+})
+
+test('지목한 역할에 사람이 있으면 찬 것이다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('r2')], peopleIn('r1', 'r2'))
+
+  assert.deepEqual(standing, { approvers: 2 })
+})
+
+test('결재선 자체가 없으면 approval-line-missing', async () => {
+  assert.deepEqual(await judgeApprovalLine([], peopleIn()), { approvers: 0, refusal: { code: 'approval-line-missing' } })
+  assert.deepEqual(await judgeApprovalLine(undefined, peopleIn()), { approvers: 0, refusal: { code: 'approval-line-missing' } })
+})
+
+/**
+ * 이것이 이 판단을 고친 이유다 — 앞서는 「찼다」로 읽고, 상신하는 순간 워크리스트가 던졌다.
+ */
+test('역할은 있는데 사람이 없으면 approval-role-empty — 어느 역할인지 함께 낸다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('r2')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r2' } } })
+})
+
+test('역할을 지목해 놓고 값이 없으면 찬 것이 아니다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Role' }], peopleIn('r1'))
+
+  assert.ok(standing.refusal, '안 서는 결재선인데 사유가 없습니다')
+})
+
+/*
+ * ── 참조 ───────────────────────────────────────────────────────────────────
+ * 참조는 결재를 막지 않는다. 그래서 세지도 않고, 그 역할이 비었다고 거절하지도 않는다.
+ */
+test('참조 자리는 사람이 없어도 막지 않는다', async () => {
+  const standing = await judgeApprovalLine([role('r1'), role('empty', 'reference')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('참조만 있는 결재선은 결재선이 없는 것이다 — 결재 없이 끝난다', async () => {
+  const standing = await judgeApprovalLine([role('r1', 'reference')], peopleIn('r1'))
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-line-missing' } })
+})
+
+test('participation 이 비어 있으면 결재다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Role', value: 'r1' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r1' } } })
+})
+
+/** 참조 자리의 역할은 **읽지도 않는다** — 읽으면 결재와 무관한 조회가 는다. */
+test('참조 자리의 역할은 묻지 않는다', async () => {
+  const asked: string[] = []
+
+  await judgeApprovalLine([role('r1'), role('r9', 'reference')], {
+    roleHasMembers: async id => {
+      asked.push(id)
+      return true
+    },
+    personIsHere: async () => true
+  })
+
+  assert.deepEqual(asked, ['r1'])
+})
+
+/*
+ * ── 사람을 직접 지목한 자리 ────────────────────────────────────────────────
+ * 「이 제품은 역할만 쓴다」로 닫지 않는다. 닫으면 없는 사람을 지목한 결재선이 「찼다」로 그려지고,
+ * 역할에서 고친 그 모양이 사람 축으로 다시 난다.
+ */
+test('지목한 사람이 있으면 찬 것이다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Employee', value: 'u1' }], peopleIn('u1'))
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('지목한 사람이 여기 없으면 approval-person-absent — 누구인지 함께 낸다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Employee', value: 'u1' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 0, refusal: { code: 'approval-person-absent', params: { personId: 'u1' } } })
+})
+
+/** 상신할 때 그 사람으로 풀리는 자리다. 미리 셀 것이 없다. */
+test('Myself 같은 상대 지목은 미리 묻지 않는다', async () => {
+  const standing = await judgeApprovalLine([{ type: 'Myself' }], peopleIn())
+
+  assert.deepEqual(standing, { approvers: 1 })
+})
+
+test('읽어야 할 역할만 골라 낸다 — 참조와 사람 지목은 뺀다', () => {
+  const named = rolesNamedIn([
+    role('r1'),
+    role('r2', 'reference'),
+    { type: 'Employee', value: 'u1' },
+    { type: 'Role' }
+  ])
+
+  assert.deepEqual(named, ['r1'])
+})

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

@@ -0,0 +1,97 @@
+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'
+
+/*
+ * ═══════════════════════════════════════════════════════════════════════════
+ * registerEnumType puts the enum's MEMBER NAMES on the wire, not their values. So the server sends
+ * "Off" while the judge, the translation keys and the CSS classes all say "off". Nothing throws:
+ * i18next prints the key it could not find, and the class simply never matches.
+ *
+ * Measured on the running server before this was fixed: twelve rows reading
+ * "text.door-standing-Off", and every status pill falling back to the inherited text colour because
+ * .mark.off never matched .mark.Off.
+ *
+ * These tests read the enum out of the server source rather than importing it - that module carries
+ * decorators, which the test harness cannot load.
+ * ═══════════════════════════════════════════════════════════════════════════
+ */
+
+const TYPE_SOURCE = readFileSync(
+  join(__dirname, '..', 'server', 'service', 'work-door', 'work-door-type.ts'),
+  'utf-8'
+)
+
+/** `Off = 'off'` → ['Off', 'off'], for the one enum named. */
+function members(enumName: string): [string, string][] {
+  const block = TYPE_SOURCE.split(`export enum ${enumName} {`)[1]
+
+  assert.ok(block, `${enumName} 을 찾지 못했습니다 — 이름이 바뀌었으면 이 시험도 함께 고쳐야 합니다`)
+
+  return [...block.split('\n}')[0].matchAll(/^\s*([A-Za-z]+)\s*=\s*'([^']+)'/gm)].map(one => [one[1], one[2]])
+}
+
+test('every standing the server can send has a word here', () => {
+  const declared = members('DoorStandingValue')
+
+  assert.ok(declared.length >= 4, `상태를 ${declared.length}개만 읽었습니다`)
+
+  for (const [wire, value] of declared) {
+    assert.equal(standingWord(wire), value, `${wire} 이 전선으로 오면 화면이 못 읽습니다`)
+  }
+})
+
+test('every kind the server can send has a word here', () => {
+  const declared = members('DoorKindValue')
+
+  assert.ok(declared.length >= 2, `종류를 ${declared.length}개만 읽었습니다`)
+
+  for (const [wire, value] of declared) {
+    assert.equal(kindWord(wire), value, `${wire} 이 전선으로 오면 화면이 못 읽습니다`)
+  }
+})
+
+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]))
+
+  assert.deepEqual(Object.keys(DOOR_STANDING_WORD).filter(one => !standings.has(one)), [])
+  assert.deepEqual(Object.keys(DOOR_KIND_WORD).filter(one => !kinds.has(one)), [])
+})
+
+test('an unknown spelling answers nothing — the screen must not paint a guess', () => {
+  assert.equal(standingWord('Whatever'), undefined)
+  assert.equal(kindWord('Whatever'), undefined)
+})
+
+/*
+ * The word is not enough on its own: the screen builds `text.door-standing-<word>` and a CSS class
+ * from it. Either one missing is silent.
+ */
+test('every word has a line to show for it, in every language we ship', () => {
+  const missing: string[] = []
+
+  for (const lang of ['ko', 'en', 'ja', 'zh', 'ms']) {
+    const said = JSON.parse(
+      readFileSync(join(__dirname, '..', 'translations', `${lang}.json`), 'utf-8')
+    ) as Record<string, string>
+
+    for (const word of Object.values(DOOR_STANDING_WORD)) {
+      if (!said[`text.door-standing-${word}`]) missing.push(`${lang} · text.door-standing-${word}`)
+    }
+    for (const word of Object.values(DOOR_KIND_WORD)) {
+      if (!said[`text.door-kind-${word}`]) missing.push(`${lang} · text.door-kind-${word}`)
+    }
+  }
+
+  assert.deepEqual(missing, [], `\n없는 문구는 화면에 키 글자로 뜹니다:\n${missing.join('\n')}`)
+})
+
+test('every word has a colour to paint — a class nothing styles is invisible, not absent', () => {
+  const styles = readFileSync(join(__dirname, '..', 'client', 'pages', 'work-door', 'work-doors-page.ts'), 'utf-8')
+  const missing = Object.values(DOOR_STANDING_WORD).filter(word => !styles.includes(`.${word}`))
+
+  assert.deepEqual(missing, [], `\n이 상태에는 칠할 것이 없습니다: ${missing.join(' · ')}`)
+})

package/tests/work-door.test.ts

@@ -0,0 +1,222 @@
+import { strict as assert } from 'node:assert'
+
+import { doorsToFill, judgeDoor, summarizeDoors } 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 })
+
+describe('work door standing', () => {
+  /**
+   * A door that borrows another door's line has no line of its own to fill. If the sentence did not say
+   * so, an administrator would go to that door to fill a line the raise never reads (ADR-0047 ⑨).
+   */
+  it('says where the line is set when a door follows another door', () => {
+    const standing = judgeDoor(
+      approval('통제 해제 승인', {
+        follows: '화면 발행 승인',
+        installed: { approvalLine: [{}] },
+        approvalStanding: { approvers: 1 }
+      })
+    )
+    const empty = judgeDoor(
+      approval('통제 해제 승인', {
+        follows: '화면 발행 승인',
+        installed: {},
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-line-missing' } }
+      })
+    )
+
+    assert.equal(standing.standing, 'on')
+    assert.ok(standing.because.includes('「화면 발행 승인」 의 결재선을 따르므로'))
+    assert.equal(empty.standing, 'off')
+    assert.ok(empty.because.includes('「화면 발행 승인」 의 결재선을 따르므로'), empty.because)
+  })
+
+  it('reads a filled approval line as standing, and says how many it passes', () => {
+    const door = judgeDoor(
+      approval('실적 정정 승인', {
+        installed: { approvalLine: [{}, {}] },
+        approvalStanding: { approvers: 2 }
+      })
+    )
+
+    assert.equal(door.standing, 'on')
+    assert.equal(door.approvers, 2)
+    assert.ok(door.because.includes('결재자 2명'))
+  })
+
+  /**
+   * A line that names a role nobody holds counts as no line at all — the screen used to read it as
+   * standing and the raise then threw `approver is not set` (ADR-0047 ③).
+   */
+  it('reads a role that holds people as standing', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Role', value: 'r1' }] },
+        approvalStanding: { approvers: 1 }
+      })
+    )
+
+    assert.equal(door.standing, 'on')
+    assert.equal(door.approvers, 1)
+  })
+
+  /**
+   * The administrator's next move differs: filling a line is not the same job as putting a person
+   * in a role, and saying the first sends them back to a line they already set.
+   */
+  it('says an empty role needs a person, not a new approval line', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Role', value: 'r1' }] },
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-role-empty', params: { role: 'r1' } } }
+      })
+    )
+
+    assert.equal(door.standing, 'off')
+    assert.equal(door.approvers, 0)
+    assert.ok(door.because.includes('역할에 사람이 없습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인한'))
+  })
+
+  /** A named person who is not here is the same defect on the other axis (ADR-0047 ③). */
+  it('says a named person who is gone needs a different name, not a new line', () => {
+    const door = judgeDoor(
+      approval('출하 승인', {
+        installed: { approvalLine: [{ type: 'Employee', value: 'u1' }] },
+        approvalStanding: { approvers: 0, refusal: { code: 'approval-person-absent', params: { personId: 'u1' } } }
+      })
+    )
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('지목한 사람이 이 공장에 없습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인한'))
+  })
+
+  /** Not having read the line must not read as "the line is filled". */
+  it('treats an unread approval line as empty rather than filled', () => {
+    const door = judgeDoor(approval('출하 승인', { installed: { approvalLine: [{ type: 'Role', value: 'r1' }] } }))
+
+    assert.equal(door.standing, 'off')
+  })
+
+  /**
+   * 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.
+   */
+  it('says an empty approval line means the raiser approves their own', () => {
+    const door = judgeDoor(approval('폐기 실행 승인', { installed: { approvalLine: [] } }))
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('자기 건을 승인한'))
+  })
+
+  /**
+   * The two kinds fail in opposite directions — an empty approval passes through, an unassigned
+   * door reaches nobody. One shared sentence would leave the reader with the wrong action.
+   */
+  it('says an unassigned door reaches nobody, not that it passes through', () => {
+    const door = judgeDoor(assignment('작업 지시 배정', { installed: { assigneeRole: undefined } }))
+
+    assert.equal(door.standing, 'off')
+    assert.ok(door.because.includes('아무에게도 가지 않습니다'))
+    assert.ok(!door.because.includes('자기 건을 승인'))
+  })
+
+  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'))
+  })
+
+  /** An approval line on an assignment door is not what fills it, and must not read as standing. */
+  it('does not let an approval line stand in for an assignee role', () => {
+    assert.equal(judgeDoor(assignment('배정', { installed: { approvalLine: [{}, {}] } })).standing, 'off')
+  })
+
+  it('treats a line that is absent the same as one that is empty', () => {
+    assert.equal(judgeDoor(approval('Y', { installed: {} })).standing, 'off')
+  })
+
+  /** A door that never installed is our failure, not the plant's choice, and must not read alike. */
+  it('separates a door that never installed from one the plant left empty', () => {
+    const door = judgeDoor(approval('초품 검사 승인'))
+
+    assert.equal(door.standing, 'missing')
+    assert.ok(door.because.includes('세우지 못한 것'))
+  })
+
+  describe('a plant that says it does not use one', () => {
+    /**
+     * Without this the survey nags for ever, and people stop reading it — and then one genuinely
+     * empty door is lost in the nagging (architect, 2026-09-11).
+     */
+    it('reads as not-used and carries the reason', () => {
+      const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '폐기는 본사가 처리합니다' }))
+
+      assert.equal(door.standing, 'not-used')
+      assert.ok(door.because.includes('폐기는 본사가 처리합니다'))
+    })
+
+    /** Said first, or a plant that opted out keeps being told its missing form is a defect. */
+    it('wins over a form that never installed', () => {
+      const door = judgeDoor(approval('폐기 실행 승인', { notUsedBecause: '안 씁니다', installed: undefined }))
+
+      assert.equal(door.standing, 'not-used')
+      assert.ok(!door.because.includes('결함'))
+    })
+
+    it('is never counted as something to fill', () => {
+      const doors = [
+        judgeDoor(approval('a', { notUsedBecause: '안 씁니다' })),
+        judgeDoor(approval('b', { installed: { approvalLine: [] } }))
+      ]
+
+      assert.equal(doorsToFill(doors), 1)
+    })
+  })
+})
+
+describe('summary', () => {
+  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([]), '이 제품이 세우는 업무 양식이 없습니다.')
+  })
+})

package/things-factory.config.js

@@ -28,6 +28,11 @@ export default {
     { tagname: 'activity-thread-list-page', page: 'activity-thread-list' },
     { tagname: 'installable-activity-list-page', page: 'installable-activity-list' },
     { tagname: 'activity-approval-list-page', page: 'activity-approval-list' },
-    { tagname: 'activity-stats-list-page', page: 'activity-stats-list' }
+    { tagname: 'activity-stats-list-page', page: 'activity-stats-list' },
+    /*
+     * 셸은 이 짝이 있어야 요소를 만든다. `route()` 가 이름을 알아도 여기 없으면 **오류 없이 빈 화면**이다.
+     * operato-plant 가 두 번 밟았고(2026-09-03 · 09-15), 이 화면이 그 제품에서 옮겨 올 때 세 번째였다.
+     */
+    { tagname: 'work-doors-page', page: 'work-doors-page' }
   ]
 }

package/translations/en.json

@@ -233,6 +233,12 @@
   "text.decision-keys-count": "{n} decision key(s)",
   "text.door-filled-from": "set in {name}",
   "text.door-form-from": "{name}'s form — it cannot be changed from here",
+  "text.door-kind-approval": "approval",
+  "text.door-kind-assignment": "assignment",
+  "text.door-standing-missing": "form not installed",
+  "text.door-standing-not-used": "not used",
+  "text.door-standing-off": "no approvers",
+  "text.door-standing-on": "in use",
   "text.draft": "draft",
   "text.due-just-passed": "just passed",
   "text.due-left-in": "{span} left",

package/translations/ja.json

@@ -233,6 +233,12 @@
   "text.decision-keys-count": "判断項目 {n}件",
   "text.door-filled-from": "{name} で設定されています",
   "text.door-form-from": "{name} のフォームです — ここでは変更できません",
+  "text.door-kind-approval": "承認",
+  "text.door-kind-assignment": "割当",
+  "text.door-standing-missing": "様式なし",
+  "text.door-standing-not-used": "使用しない",
+  "text.door-standing-off": "承認者なし",
+  "text.door-standing-on": "使用中",
   "text.draft": "ドラフト保存",
   "text.due-just-passed": "過ぎたところ",
   "text.due-left-in": "残り{span}",

package/translations/ko.json

@@ -233,6 +233,12 @@
   "text.decision-keys-count": "판단 항목 {n}개",
   "text.door-filled-from": "{name} 에서 정했습니다",
   "text.door-form-from": "{name} 의 양식입니다 — 여기서는 못 고칩니다",
+  "text.door-kind-approval": "결재",
+  "text.door-kind-assignment": "배정",
+  "text.door-standing-missing": "양식 없음",
+  "text.door-standing-not-used": "안 씀",
+  "text.door-standing-off": "결재자 없음",
+  "text.door-standing-on": "사용 중",
   "text.draft": "초안저장",
   "text.due-just-passed": "방금 지남",
   "text.due-left-in": "{span} 남음",

package/translations/ms.json

@@ -233,6 +233,12 @@
   "text.decision-keys-count": "{n} kunci keputusan",
   "text.door-filled-from": "ditetapkan di {name}",
   "text.door-form-from": "Borang {name} — tidak boleh diubah dari sini",
+  "text.door-kind-approval": "kelulusan",
+  "text.door-kind-assignment": "tugasan",
+  "text.door-standing-missing": "borang tiada",
+  "text.door-standing-not-used": "tidak digunakan",
+  "text.door-standing-off": "tiada pelulus",
+  "text.door-standing-on": "sedang digunakan",
   "text.draft": "draf",
   "text.due-just-passed": "baru lewat",
   "text.due-left-in": "tinggal {span}",

package/translations/zh.json

@@ -233,6 +233,12 @@
   "text.decision-keys-count": "判断项 {n} 个",
   "text.door-filled-from": "在 {name} 中设定",
   "text.door-form-from": "{name} 的表单 — 此处无法修改",
+  "text.door-kind-approval": "审批",
+  "text.door-kind-assignment": "指派",
+  "text.door-standing-missing": "无样式",
+  "text.door-standing-not-used": "不使用",
+  "text.door-standing-off": "无审批人",
+  "text.door-standing-on": "使用中",
   "text.draft": "草稿",
   "text.due-just-passed": "刚刚超期",
   "text.due-left-in": "剩余{span}",