@things-factory/auth-base 10.1.278 → 10.1.280

package/tests/privilege-directive.test.ts

@@ -1,332 +0,0 @@
-/**
- * `@privilege` 지시자 — **이음매** 시험.
- *
- * `permission-gate.test.ts` 는 판정 규칙을 본다. 그런데 규칙이 옳아도 **부르는 자리**가 틀리면
- * 화면은 열린다. 그 자리가 이 지시자다: 스키마의 모든 필드를 훑어 게이트를 감싸고, 거절을
- * `extensions` 와 함께 던진다. 지시자 안에 인라인으로 있던 문장 만들기는 이미 떼어냈는데
- * (`privilege-rejection.ts`), **감싸는 행위 자체**에는 시험이 없었다.
- *
- * 그래서 여기서는 실제로 스키마를 짓고 쿼리를 태운다. type-graphql 리졸버는 jest 에서 들 수
- * 없으므로(tests/compiled.ts) SDL 로 같은 모양을 만든다 — 지시자가 보는 것은 필드 설정과
- * `context.state` 뿐이므로 판정 경로는 동일하다.
- */
-
-import { graphql } from 'graphql'
-import { makeExecutableSchema } from '@graphql-tools/schema'
-
-import { loadCompiled } from './compiled'
-
-const { privilegeDirectiveTypeDefs, privilegeDirectiveResolver, privilegeOfField } = loadCompiled(
-  'service/privilege/privilege-directive'
-)
-const { User } = loadCompiled('service/user/user')
-
-const DOMAIN = { id: 'domain-1', subdomain: 'plant-a' }
-const USER = { id: 'user-1', domains: [DOMAIN] }
-
-/**
- * 지시자가 붙은 필드와 붙지 않은 필드를 나란히 둔다 — 이 대비가 「기본값이 열려 있다」를
- * 눈으로 보여 준다.
- */
-const typeDefs = `
-  type Query {
-    guardedBoard: String @privilege(category: "board", privilege: "mutation")
-    ownershipOnly: String @privilege(domainOwnerGranted: true)
-    undeclared: String
-  }
-`
-
-function buildSchema() {
-  const schema = makeExecutableSchema({
-    typeDefs: [privilegeDirectiveTypeDefs, typeDefs],
-    resolvers: {
-      Query: {
-        guardedBoard: () => 'board',
-        ownershipOnly: () => 'ownership',
-        undeclared: () => 'undeclared'
-      }
-    }
-  })
-
-  return privilegeDirectiveResolver(schema)
-}
-
-function run(schema: any, field: string, state: any = {}) {
-  return graphql({
-    schema,
-    source: `{ ${field} }`,
-    contextValue: { state: { domain: DOMAIN, user: USER, ...state } }
-  })
-}
-
-function withOwnership({ owner = false, superUser = false } = {}) {
-  ;(process as any).domainOwnerGranted = jest.fn().mockResolvedValue(owner)
-  ;(process as any).superUserGranted = jest.fn().mockResolvedValue(superUser)
-}
-
-beforeEach(() => {
-  withOwnership()
-  User.hasPrivilege = jest.fn().mockResolvedValue(false)
-})
-
-afterEach(() => {
-  delete (process as any).domainOwnerGranted
-  delete (process as any).superUserGranted
-})
-
-describe('선언하지 않은 필드', () => {
-  it('아무 권한 없이 열린다 — 지시자를 잊으면 게이트가 없다', async () => {
-    const result = await run(buildSchema(), 'undeclared')
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({ undeclared: 'undeclared' })
-  })
-
-  it('사용자가 없어도 열린다 — 게이트가 아예 감싸지지 않았다', async () => {
-    const result = await run(buildSchema(), 'undeclared', { user: undefined })
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({ undeclared: 'undeclared' })
-  })
-})
-
-describe('선언한 필드', () => {
-  it('역할이 있으면 값을 준다', async () => {
-    User.hasPrivilege = jest.fn().mockResolvedValue(true)
-
-    const result = await run(buildSchema(), 'guardedBoard')
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({ guardedBoard: 'board' })
-  })
-
-  it('역할이 없으면 값을 주지 않고 거절한다', async () => {
-    const result = await run(buildSchema(), 'guardedBoard')
-
-    expect(result.data).toEqual({ guardedBoard: null })
-    expect(result.errors).toHaveLength(1)
-  })
-
-  it('거절에 무엇이 필요했는지를 구조로 싣는다 — 화면이 문장을 파싱하지 않는다', async () => {
-    const result = await run(buildSchema(), 'guardedBoard')
-    const { code, requires } = result.errors![0].extensions as any
-
-    expect(code).toBe('FORBIDDEN')
-    expect(requires).toEqual({ category: 'board', privilege: 'mutation' })
-  })
-
-  it('요청의 언어로 거절한다', async () => {
-    const schema = buildSchema()
-    const result = await graphql({
-      schema,
-      source: '{ guardedBoard }',
-      contextValue: {
-        state: { domain: DOMAIN, user: USER },
-        t: (key: string, params: any) => `${params.x} 권한이 필요합니다.`
-      }
-    })
-
-    expect(result.errors![0].message).toBe('board:mutation 권한이 필요합니다.')
-  })
-})
-
-describe('소유권만 선언한 필드', () => {
-  it('소유자에게 열린다', async () => {
-    withOwnership({ owner: true })
-
-    const result = await run(buildSchema(), 'ownershipOnly')
-
-    expect(result.errors).toBeUndefined()
-    expect(result.data).toEqual({ ownershipOnly: 'ownership' })
-  })
-
-  it('소유자가 아니면 거절하고, 필요한 것을 `ownership` 으로 말한다', async () => {
-    const result = await run(buildSchema(), 'ownershipOnly')
-
-    expect(result.errors).toHaveLength(1)
-    expect((result.errors![0].extensions as any).requires).toBe('ownership')
-  })
-})
-
-describe('안전하지 않은 IP 가 이음매를 지나 게이트까지 간다', () => {
-  it('금지 목록이 실려 판정을 바꾼다', async () => {
-    User.hasPrivilege = jest.fn().mockResolvedValue(true)
-
-    const allowed = await run(buildSchema(), 'guardedBoard', { unsafeIP: true })
-    expect(allowed.errors).toBeUndefined()
-
-    const prohibited = await run(buildSchema(), 'guardedBoard', {
-      unsafeIP: true,
-      prohibitedPrivileges: [{ category: 'board', privilege: 'mutation' }]
-    })
-    expect(prohibited.errors).toHaveLength(1)
-  })
-})
-
-describe('스키마를 지으면서 남기는 것', () => {
-  it('선언한 (category, privilege) 를 전역 레지스트리에 등록한다', () => {
-    /* 부팅 때 없는 권한 행을 만드는 근거다 — 마이그레이션도 수동 생성도 필요 없다. */
-    buildSchema()
-
-    expect((process as any).PRIVILEGES['board mutation']).toEqual(['board', 'mutation'])
-  })
-
-  /*
-   * What each field asks for, by name — so another entrance to the same door (an AI tool) reads
-   * the door's own declaration instead of copying it (operato-twin ADR-0071 / ADR-0072).
-   */
-  it('records what a declared field asks for, all four parts', () => {
-    buildSchema()
-
-    expect(privilegeOfField('Query', 'guardedBoard')).toEqual({
-      known: true,
-      gate: { category: 'board', privilege: 'mutation', owner: false, super: false }
-    })
-  })
-
-  it('records an ownership-only field too — it names no pair but it is still a gate', () => {
-    buildSchema()
-
-    expect(privilegeOfField('Query', 'ownershipOnly')).toEqual({
-      known: true,
-      gate: { category: undefined, privilege: undefined, owner: true, super: false }
-    })
-  })
-
-  it('says a root field with no directive is known and open', () => {
-    buildSchema()
-
-    expect(privilegeOfField('Query', 'undeclared')).toEqual({ known: true, gate: null })
-  })
-
-  it('does not call a field it has never seen open — a typo is not an open door', () => {
-    buildSchema()
-
-    expect(privilegeOfField('Query', 'guardedBord')).toEqual({ known: false })
-  })
-
-  it('필드 설명에 필요한 권한을 적어 둔다', async () => {
-    const schema = buildSchema()
-    const description = (schema.getQueryType() as any).getFields().guardedBoard.description
-
-    expect(description).toContain('board:mutation')
-  })
-})
-
-/*
- * ── A declaration that names nothing stops the boot ───────────────────────────
- * Schema assembly is the only moment this can be caught. After it, an empty declaration is
- * indistinguishable from a real one at the call site: the directive is present, the wrapper
- * runs, and the answer comes back from `checkPermission` with nothing to look up.
- *
- * `@privilege()` was the worst of these — it answered by the caller's address, refusing from a
- * safe one and passing everyone from an unsafe one, so whoever tried it learned the opposite
- * lesson depending on where they sat (architect, 2026-09-15).
- *
- * [확인함] 2026-09-15 · six repositories · zero declarations of either shape, so refusing them
- * breaks nothing that exists. The throw is for the one someone writes next.
- */
-describe('a declaration that names nothing', () => {
-  function buildField(declaration: string) {
-    const schema = makeExecutableSchema({
-      typeDefs: [privilegeDirectiveTypeDefs, `type Query { field: String ${declaration} }`],
-      resolvers: { Query: { field: () => 'value' } }
-    })
-
-    return () => privilegeDirectiveResolver(schema)
-  }
-
-  it('refuses an empty declaration, and names the field', () => {
-    expect(buildField('@privilege')).toThrow(/Query\.field declares nothing/)
-  })
-
-  it('tells the writer what the two real shapes are', () => {
-    expect(buildField('@privilege')).toThrow(/domainOwnerGranted/)
-    expect(buildField('@privilege')).toThrow(/carries no directive at all/)
-  })
-
-  it('refuses a category with no privilege', () => {
-    expect(buildField('@privilege(category: "board")')).toThrow(/a category with no privilege/)
-  })
-
-  it('refuses a privilege with no category', () => {
-    expect(buildField('@privilege(privilege: "mutation")')).toThrow(/a privilege with no category/)
-  })
-
-  /*
-   * ── An axis this installation does not declare ──────────────────────────────
-   * A typo used to be the quietest defect in the file. `privilege: "mutaiton"` registered a
-   * pair in `process['PRIVILEGES']` that no role would ever hold — the field was shut to
-   * everyone, permanently, and nothing said so. The framework does not own the word list
-   * (dssp declares eight of its own), so the check asks the installation.
-   */
-  it('refuses an axis outside the declared vocabulary', () => {
-    expect(buildField('@privilege(category: "board", privilege: "mutaiton")')).toThrow(
-      /uses axis "mutaiton", which this installation does not declare/
-    )
-  })
-
-  it('tells the reader what is declared and where to declare more', () => {
-    const build = buildField('@privilege(category: "board", privilege: "approve")')
-
-    expect(build).toThrow(/Declared axes: mutation, query/)
-    /* The hook a module would reach for runs after the schema is built, so it must say so. */
-    expect(build).toThrow(/top level of the module's server\/index\.ts/)
-    expect(build).toThrow(/too late/)
-  })
-
-  it('accepts an axis once the installation declares it', () => {
-    const { declareAxes } = loadCompiled('service/privilege/privilege-axis')
-
-    expect(buildField('@privilege(category: "kpi", privilege: "read")')).toThrow()
-
-    declareAxes(['query', 'mutation', 'read'])
-
-    expect(buildField('@privilege(category: "kpi", privilege: "read")')).not.toThrow()
-  })
-
-  it('still builds the two shapes that do name something', () => {
-    expect(buildField('@privilege(category: "board", privilege: "mutation")')).not.toThrow()
-    expect(buildField('@privilege(domainOwnerGranted: true)')).not.toThrow()
-    expect(buildField('@privilege(superUserGranted: true)')).not.toThrow()
-  })
-})
-
-describe('거절이 이유를 싣는다 (ADR-0103 결정 1)', () => {
-  it('★ 역할이 없으면 because: role — 화면이 「권한 요청」을 띄운다', async () => {
-    const result = await run(buildSchema(), 'guardedBoard')
-    expect((result.errors![0].extensions as any).because).toBe('role')
-  })
-
-  it('★ 라이선스가 막으면 역할이 있어도 because: license — 요청할 것이 아니다', async () => {
-    User.hasPrivilege = jest.fn().mockResolvedValue(true)
-    const result = await run(buildSchema(), 'guardedBoard', {
-      prohibitedPrivileges: [{ category: 'board', privilege: 'mutation', by: 'license' }]
-    })
-    expect((result.errors![0].extensions as any).because).toBe('license')
-  })
-
-  it('★ 보호 주소 밖에서 소유자 전용이면 because: address', async () => {
-    withOwnership({ owner: true })
-    const result = await run(buildSchema(), 'ownershipOnly', { unsafeIP: true })
-    expect((result.errors![0].extensions as any).because).toBe('address')
-  })
-})
-
-describe('거절이 무엇이 막혔는지도 싣는다 — 변경인가 조회인가 (질문지 Q9 · 4)', () => {
-  it('★ 조회가 막히면 operation: query', async () => {
-    const result = await run(buildSchema(), 'guardedBoard')
-    expect((result.errors![0].extensions as any).operation).toBe('query')
-  })
-
-  it('★ 변경이 막히면 operation: mutation — 사람이 누른 일이다', async () => {
-    const schema = privilegeDirectiveResolver(
-      makeExecutableSchema({
-        typeDefs: [privilegeDirectiveTypeDefs, 'type Query { ok: String } type Mutation { saveBoard: String @privilege(category: "board", privilege: "mutation") }'],
-        resolvers: { Query: { ok: () => 'ok' }, Mutation: { saveBoard: () => 'saved' } }
-      })
-    )
-    const result = await graphql({ schema, source: 'mutation { saveBoard }', contextValue: { state: { domain: DOMAIN, user: USER } } })
-    expect((result.errors![0].extensions as any)).toMatchObject({ because: 'role', operation: 'mutation' })
-  })
-})

package/tests/privilege-rejection.test.ts

@@ -1,104 +0,0 @@
-/**
- * 권한 거절 문장 테스트.
- *
- * 이 문장은 프레임워크 apollo 링크를 타고 **사용자 얼굴까지** 간다(자동으로 닫히지 않는 오류 토스트).
- * 예전에는 영어 한 문장이었고, 나머지 서버 오류가 모두 `context.t` 로 옮겨진 뒤에도 여기만 남아 있었다.
- *
- * 위험한 것은 게이트 판정이 아니라 문장 만들기다:
- *  ① 번역기가 없는 컨텍스트(구독·내부 호출)에서 죽거나 빈 문장을 주면 사용자는 이유를 못 본다.
- *  ② i18next 는 키를 못 찾으면 **키를 그대로 돌려준다** — 그걸 쓰면 `error.x privilege required` 가 보인다.
- *  ③ 소비처가 문장 형태에 의존하면 번역하는 순간 깨진다 — 그래서 `extensions` 에 구조로 싣는다.
- */
-
-import { privilegeRejection } from '../server/service/privilege/privilege-rejection.js'
-
-/** 키를 그대로 돌려주는 i18next 기본 거동(번역 누락). */
-const missing = (key: string) => key
-
-describe('privilege rejection', () => {
-  it('요청의 언어로 말한다', () => {
-    const context = { t: (key: string, params: any) => `${params.x} 권한이 필요합니다.` }
-
-    expect(privilegeRejection(context, 'twin', 'mutation').message).toBe('twin:mutation 권한이 필요합니다.')
-  })
-
-  it('번역기가 없어도 이유를 말한다 — 빈 문장이나 예외로 끝나지 않는다', () => {
-    for (const context of [undefined, null, {}, { t: 'not a function' }]) {
-      const error = privilegeRejection(context, 'twin', 'mutation')
-
-      expect(error.message).toBe('unauthorized! twin:mutation privilege required')
-    }
-  })
-
-  it('번역이 없는 언어에서 키가 새어 나가지 않는다', () => {
-    /* i18next 기본 거동을 그대로 쓰면 사용자가 `error.x privilege required` 를 읽는다. */
-    const error = privilegeRejection({ t: missing }, 'twin', 'mutation')
-
-    expect(error.message).toBe('unauthorized! twin:mutation privilege required')
-    expect(error.message).not.toContain('error.')
-  })
-
-  it('번역기가 던져도 거절은 그대로 전달된다 — 오류의 원인이 번역기로 바뀌지 않게', () => {
-    const context = {
-      t: () => {
-        throw new Error('i18next not initialized')
-      }
-    }
-
-    expect(privilegeRejection(context, 'twin', 'mutation').message).toBe(
-      'unauthorized! twin:mutation privilege required'
-    )
-  })
-
-  it('소유권만 요구하는 게이트는 권한 이름을 지어내지 않는다', () => {
-    /* `@privilege(domainOwnerGranted: true)` 처럼 category·privilege 가 없는 게이트가 실제로 있다. */
-    const error = privilegeRejection({ t: missing })
-
-    expect(error.message).toBe('unauthorized! domain or system ownership required')
-    expect(error.extensions.requires).toBe('ownership')
-  })
-
-  it('무엇이 필요했는지 구조로 싣는다 — 화면이 문장을 다시 파싱하지 않게', () => {
-    const error = privilegeRejection({ t: () => '번역된 문장' }, 'twin', 'mutation')
-
-    expect(error.extensions.code).toBe('FORBIDDEN')
-    expect(error.extensions.requires).toEqual({ category: 'twin', privilege: 'mutation' })
-  })
-
-  it('한쪽만 주어진 게이트는 소유권 요구로 본다 — `undefined:mutation` 같은 문장을 만들지 않는다', () => {
-    expect(privilegeRejection({}, 'twin', undefined).extensions.requires).toBe('ownership')
-    expect(privilegeRejection({}, undefined, 'mutation').extensions.requires).toBe('ownership')
-  })
-})
-
-describe('privilege rejection carries why (ADR-0103 decision 1)', () => {
-  it('★ the cause goes in extensions.because - a screen offers a request only for role', () => {
-    expect(privilegeRejection(undefined, 'twin', 'mutation', 'license').extensions).toEqual({
-      code: 'FORBIDDEN',
-      requires: { category: 'twin', privilege: 'mutation' },
-      because: 'license'
-    })
-  })
-
-  it('a caller that does not say keeps the old meaning - named is role, unnamed is ownership', () => {
-    expect(privilegeRejection(undefined, 'twin', 'mutation').extensions.because).toBe('role')
-    expect(privilegeRejection(undefined).extensions.because).toBe('ownership')
-  })
-
-  it('★ each cause has its own sentence - an address refusal does not say a privilege is missing', () => {
-    const address = privilegeRejection(undefined, 'twin', 'mutation', 'address').message
-    const license = privilegeRejection(undefined, 'twin', 'mutation', 'license').message
-    const role = privilegeRejection(undefined, 'twin', 'mutation', 'role').message
-    expect(new Set([address, license, role]).size).toBe(3)
-    expect(address).toContain('address')
-    expect(license).toContain('licensed')
-  })
-
-  it('every sentence key is in all six languages', () => {
-    const keys = ['error.x not allowed from this address', 'error.x not licensed', 'error.x refused for this request', 'error.ownership not allowed from this address']
-    for (const lng of ['en', 'ko', 'ja', 'zh', 'ms', 'es']) {
-      const dict = require(`../translations/${lng}.json`)
-      for (const key of keys) expect([lng, key, typeof dict[key]]).toEqual([lng, key, 'string'])
-    }
-  })
-})

package/tests/privilege-sync-db.test.ts

@@ -1,58 +0,0 @@
-/**
- * The privilege sync is boot-time writing, and boot-time writing takes its turn (shell `inBootTurn`).
- *
- * On sqlite every transaction shares one connection. Another module's boot transaction (work-shift's
- * baseline) that began while the sync's insert was open failed with "cannot start a transaction within a
- * transaction", and its rollback took the insert with it — so the same privilege was missing again on
- * the next boot, and the collision repeated every boot (`contact/query`, operato-plant, 2026-10-10).
- */
-import { inBootTurn } from '@things-factory/shell'
-
-import { closeAuthDatabase, Domain, getRepository, openAuthDatabase, resetAuthDatabase } from './db'
-import { loadCompiled } from './compiled'
-
-const { synchronizePrivileges } = loadCompiled('service/privilege/privilege-sync')
-const { Privilege } = loadCompiled('service/privilege/privilege')
-
-const pause = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
-beforeAll(async () => {
-  await openAuthDatabase()
-})
-
-beforeEach(async () => {
-  await resetAuthDatabase()
-})
-
-afterAll(async () => {
-  await closeAuthDatabase()
-})
-
-test('adds what is missing and leaves what is there', async () => {
-  await getRepository(Privilege).save({ category: 'contact', name: 'mutation' })
-
-  expect(await synchronizePrivileges([['contact', 'mutation'], ['contact', 'query']])).toEqual(['contact/query'])
-  expect(await getRepository(Privilege).countBy({ category: 'contact' })).toBe(2)
-})
-
-test('another boot job that fails does not take the sync with it', async () => {
-  const dataSource = await openAuthDatabase()
-
-  /*
-   * A boot job of another module, in its turn: it holds a transaction for a while and then fails. On
-   * sqlite TypeORM shares one query runner, so a save that starts meanwhile rides inside that
-   * transaction — and goes when it rolls back.
-   */
-  const other = inBootTurn(() =>
-    dataSource.transaction(async tx => {
-      await tx.getRepository(Domain).save({ name: 'boot-job', subdomain: 'boot-job' })
-      await pause(30)
-      throw new Error('the other boot job failed')
-    })
-  ).catch(() => undefined)
-  const sync = synchronizePrivileges([['contact', 'query']])
-
-  await Promise.all([other, sync])
-  expect(await getRepository(Domain).countBy({ subdomain: 'boot-job' })).toBe(0)
-  expect(await getRepository(Privilege).countBy({ category: 'contact', name: 'query' })).toBe(1)
-})

package/tests/profile-user.test.ts

@@ -1,24 +0,0 @@
-import { profileUser } from '../server/utils/profile-user.js'
-
-/**
- * The profile carries the person's own id: the client names whose unsaved drafts this browser keeps by it
- * (ADR-0190). It was left out in 19ed1646178, and from then on no draft had an owner and none was written.
- */
-describe('profileUser', () => {
-  it('carries the id with what the client shows and the grants', () => {
-    const user = { id: 'u-1', username: 'kim', email: 'kim@example.com', locale: 'ko', name: '김', userType: 'user', password: 'hash', salt: 'salt' }
-    const profile = profileUser(user, { owner: false, super: false, unsafeIP: false, privileges: [] })
-    expect(profile).toEqual({
-      id: 'u-1',
-      username: 'kim',
-      email: 'kim@example.com',
-      locale: 'ko',
-      name: '김',
-      userType: 'user',
-      owner: false,
-      super: false,
-      unsafeIP: false,
-      privileges: []
-    })
-  })
-})

package/tests/refusal-cause.test.ts

@@ -1,80 +0,0 @@
-/**
- * Why the gate said no (ADR-0103 decision 1).
- *
- * The four refusals used to arrive as one sentence. Only one of them is opened by a role, so a screen
- * that offers "request access" for all four sends the admin a request they cannot answer - the person is
- * given the role and is refused again. `judgePermission` says which it was; `checkPermission` stays a boolean.
- */
-
-import { loadCompiled } from './compiled'
-
-const { judgePermission, checkPermission } = loadCompiled('utils/check-permission')
-const { User } = loadCompiled('service/user/user')
-
-const DOMAIN = { id: 'domain-1' } as any
-const USER = { id: 'user-1' } as any
-const NAMED = { category: 'warehouse', privilege: 'mutation' }
-const OWNED = { ...NAMED, owner: true }
-
-function given({ role = false, owner = false } = {}) {
-  User.hasPrivilege = jest.fn().mockResolvedValue(role)
-  ;(process as any).domainOwnerGranted = jest.fn().mockResolvedValue(owner)
-  ;(process as any).superUserGranted = jest.fn().mockResolvedValue(false)
-}
-
-afterEach(() => {
-  delete (process as any).domainOwnerGranted
-  delete (process as any).superUserGranted
-})
-
-describe('a refusal says which of the four it was', () => {
-  it('★ no role holds it: role', async () => {
-    given()
-    expect(await judgePermission(NAMED, USER, DOMAIN)).toEqual({ permitted: false, because: 'role' })
-    expect(await judgePermission(NAMED, USER, DOMAIN, true)).toEqual({ permitted: false, because: 'role' })
-  })
-
-  it('★ withheld by the address list: address - even with the role', async () => {
-    given({ role: true })
-    const prohibited = [{ ...NAMED, by: 'address' }]
-    expect(await judgePermission(NAMED, USER, DOMAIN, true, prohibited)).toEqual({ permitted: false, because: 'address' })
-  })
-
-  it('★ withheld by the license: license - even with the role', async () => {
-    given({ role: true })
-    const prohibited = [{ ...NAMED, by: 'license' }]
-    expect(await judgePermission(NAMED, USER, DOMAIN, false, prohibited)).toEqual({ permitted: false, because: 'license' })
-  })
-
-  it('★ a prohibition that does not say who made it: unknown - the cause is not made up', async () => {
-    given({ role: true })
-    expect(await judgePermission(NAMED, USER, DOMAIN, false, [NAMED])).toEqual({ permitted: false, because: 'unknown' })
-  })
-
-  it('★ only owners may: ownership', async () => {
-    given()
-    expect(await judgePermission({ owner: true }, USER, DOMAIN)).toEqual({ permitted: false, because: 'ownership' })
-  })
-
-  it('★ ownership asked from an unsafe address: address', async () => {
-    given({ owner: true })
-    expect(await judgePermission({ owner: true }, USER, DOMAIN, true)).toEqual({ permitted: false, because: 'address' })
-  })
-
-  it('★ an owner without the role, from an unsafe address: address - from a safe one they pass', async () => {
-    given({ owner: true })
-    expect(await judgePermission(OWNED, USER, DOMAIN, true)).toEqual({ permitted: false, because: 'address' })
-    expect(await judgePermission(OWNED, USER, DOMAIN, false)).toEqual({ permitted: true, by: 'domain-owner' })
-  })
-
-  it('an unsafe address whose ownership cannot be asked still refuses as role - it refused before', async () => {
-    User.hasPrivilege = jest.fn().mockResolvedValue(false)
-    expect(await judgePermission(OWNED, USER, DOMAIN, true)).toEqual({ permitted: false, because: 'role' })
-  })
-
-  it('checkPermission answers the same, as a boolean', async () => {
-    given({ role: true })
-    expect(await checkPermission(NAMED, USER, DOMAIN)).toBe(true)
-    expect(await checkPermission(NAMED, USER, DOMAIN, false, [{ ...NAMED, by: 'license' }])).toBe(false)
-  })
-})

package/tests/refusals-have-korean.test.ts

@@ -1,24 +0,0 @@
-/*
- * Every refusal this package throws has its Korean sentence - a missing one is read in the server's English fallback
- * (inline help audit 2026-10-30: passkey-not-found, and the check-in's `error.domain not specified` printed as its key).
- */
-import { readFileSync, readdirSync } from 'fs'
-import { join } from 'path'
-
-const ROOT = join(__dirname, '..')
-const ko: Record<string, string> = JSON.parse(readFileSync(join(ROOT, 'translations', 'ko.json'), 'utf8'))
-
-const sources = (dir: string): string[] =>
-  readdirSync(dir, { withFileTypes: true }).flatMap(entry => (entry.isDirectory() ? sources(join(dir, entry.name)) : /\.ts$/.test(entry.name) && !/\.test\.ts$/.test(entry.name) ? [join(dir, entry.name)] : []))
-const text = sources(join(ROOT, 'server')).map(file => readFileSync(file, 'utf8')).join('\n')
-
-test('★ every Refusal code has error.<code> in Korean', () => {
-  const codes = [...new Set([...text.matchAll(/new Refusal\(\s*'([a-z0-9-]+)'/g)].map(match => match[1]))]
-  expect(codes.length).toBeGreaterThanOrEqual(10)
-  expect(codes.filter(code => !(`error.${code}` in ko))).toEqual([])
-})
-
-test('★ the check-in refusal has its Korean sentence', () => {
-  expect(text).toMatch(/t\('error\.domain not specified'/)
-  expect(ko['error.domain not specified']).toBeTruthy()
-})