@things-factory/ai-dashboard 10.1.221 → 10.1.222

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/ai-dashboard",
-  "version": "10.1.221",
+  "version": "10.1.222",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -33,10 +33,11 @@
     "@operato/popup": "^10.29.39",
     "@operato/shell": "^10.29.39",
     "@operato/styles": "^10.0.0",
-    "@things-factory/ai-assistant": "^10.1.221",
+    "@things-factory/ai-assistant": "^10.1.222",
     "@things-factory/ai-client-base": "^10.1.218",
     "@things-factory/auth-base": "^10.1.218",
     "@things-factory/env": "^10.1.149",
+    "@things-factory/organization": "^10.1.222",
     "@things-factory/shell": "^10.1.208",
     "graphql-scalars": "^1.22.0",
     "graphql-tag": "^2.12.6",
@@ -45,5 +46,5 @@
   "devDependencies": {
     "copyfiles": "^2.4.1"
   },
-  "gitHead": "90e211d7a2c99216e017bd19a62e1703b20f2710"
+  "gitHead": "afdd6a9b1c8b440e39d4fec48bfbad1a0c02fccc"
 }

package/server/service/card/card-access.test.ts

@@ -3,13 +3,13 @@
  */
 import { listReadTarget, type DetailRead } from '@things-factory/ai-assistant'
 
-import { cardAccessOf, departmentsOfEmployees, shareRefusal } from './card-access'
+import { cardAccessOf } from './card-access'
 import { findCardProposal } from './card-proposal'
 import { proposeDashboardCard, readDashboardCard } from './card-tool'
 import { CARD_AXIS } from './card-names'
 import { CARD_AXIS as CLIENT_AXIS, cardSelection } from '../../../client/utils/card-words'
 
-const viewer = { userId: 'u-me', domainId: 'd1', departmentIds: ['dep-sales'] }
+const viewer = { userId: 'u-me', domainId: 'd1', departmentIds: ['dep-sales'], roleIds: [] as string[] }
 
 describe('who may use a card', () => {
   it('★ its owner, and whoever a share names - a person, a department one is active in, the domain', () => {
@@ -27,9 +27,6 @@ describe('who may use a card', () => {
     expect(cardAccessOf({ ownerId: 'u-x', domainId: 'd1' }, holder, [{ scope: 'ROLE', targetId: 'role-hr' }])).toBe('shared')
     expect(cardAccessOf({ ownerId: 'u-x', domainId: 'd1' }, holder, [{ scope: 'ROLE', targetId: 'role-finance' }])).toBeUndefined()
     expect(cardAccessOf({ ownerId: 'u-x', domainId: 'd1' }, viewer, [{ scope: 'ROLE', targetId: 'role-hr' }])).toBeUndefined()
-    /* A role of the domain is given; one it does not have is refused. */
-    expect(shareRefusal({ scope: 'ROLE', targetId: 'role-hr' }, { domainId: 'd1', departmentsAvailable: true, roleIds: ['role-hr'] })).toBeUndefined()
-    expect(shareRefusal({ scope: 'ROLE', targetId: 'role-other' }, { domainId: 'd1', departmentsAvailable: true, roleIds: ['role-hr'] })).toBe('unknown-role')
   })
 
   it('★ never across domains - not even its owner in another domain', () => {
@@ -38,26 +35,9 @@ describe('who may use a card', () => {
     expect(cardAccessOf({ ownerId: 'u-me', domainId: 'd1' }, { ...viewer, userId: '' }, [])).toBeUndefined()
   })
 
-  it('★ a department is one an active employee record is in - an inactive or unset record shares nothing', () => {
-    expect(
-      departmentsOfEmployees([
-        { active: true, department: { id: 'dep-sales' } },
-        { active: false, department: { id: 'dep-old' } },
-        { active: null, department: { id: 'dep-unset' } },
-        { active: true, department: null },
-        { active: true, department: { id: 'dep-sales' } }
-      ])
-    ).toEqual(['dep-sales'])
-    expect(departmentsOfEmployees(undefined)).toEqual([])
-  })
-
-  it('a share the owner may give: a known scope, a target, their own domain, departments only where they are known', () => {
-    const owner = { domainId: 'd1', departmentsAvailable: true }
-    expect(shareRefusal({ scope: 'USER', targetId: 'u-x' }, owner)).toBeUndefined()
-    expect(shareRefusal({ scope: 'TEAM', targetId: 'x' }, owner)).toBe('unknown-scope')
-    expect(shareRefusal({ scope: 'USER', targetId: '' }, owner)).toBe('no-target')
-    expect(shareRefusal({ scope: 'DOMAIN', targetId: 'd2' }, owner)).toBe('another-domain')
-    expect(shareRefusal({ scope: 'DEPARTMENT', targetId: 'dep' }, { ...owner, departmentsAvailable: false })).toBe('no-departments')
+  it('★ a department share reaches the people of the departments under it - the viewer stands in those above (organization audience)', () => {
+    const inTeam = { ...viewer, departmentIds: ['dep-sales-1', 'dep-sales'] }
+    expect(cardAccessOf({ ownerId: 'u-x', domainId: 'd1' }, inTeam, [{ scope: 'DEPARTMENT', targetId: 'dep-sales' }])).toBe('shared')
   })
 })
 

package/server/service/card/card-access.ts

@@ -4,57 +4,21 @@
  * definition, never the data behind it. Asked again on every read, run, placing and copy - a share withdrawn is gone
  * at once, whatever is still placed.
  *
+ * Whom a share reaches is the audience rule of organization (ADR-0163 decision 2) - the one an announcement asks too.
+ *
  * Pure - the rule is tested without a database.
  */
+import { audienceReaches, type AudienceMember, type AudienceTarget } from '@things-factory/organization'
 
 export type CardAccess = 'owner' | 'shared'
 
-export interface CardShareRow {
-  scope: 'USER' | 'DEPARTMENT' | 'ROLE' | 'DOMAIN' | string
-  targetId: string
-}
+export type CardShareRow = AudienceTarget
 
-export interface CardViewer {
-  userId: string
-  domainId: string
-  /** The departments of the viewer's active employee records - none where the organization module is not there. */
-  departmentIds: readonly string[]
-  /** The roles the viewer holds in the domain, the ones it inherits included - a role share reaches whoever holds it. */
-  roleIds?: readonly string[]
-}
+/** The viewer as an audience sees them - the departments they stand in (those above included) and the roles they hold. */
+export type CardViewer = AudienceMember
 
 export function cardAccessOf(card: { ownerId?: string | null; domainId?: string | null }, viewer: CardViewer, shares: readonly CardShareRow[]): CardAccess | undefined {
   if (!viewer.userId || !viewer.domainId || card.domainId !== viewer.domainId) return undefined
   if (card.ownerId === viewer.userId) return 'owner'
-  const shared = shares.some(
-    share =>
-      (share.scope === 'USER' && share.targetId === viewer.userId) ||
-      (share.scope === 'DOMAIN' && share.targetId === viewer.domainId) ||
-      (share.scope === 'DEPARTMENT' && viewer.departmentIds.includes(share.targetId)) ||
-      (share.scope === 'ROLE' && (viewer.roleIds ?? []).includes(share.targetId))
-  )
-  return shared ? 'shared' : undefined
-}
-
-/**
- * The departments a person belongs to for sharing - their employee records that are active (`active = true`; an
- * unset `active` is not taken, as the assistant's people read takes only `active eq true`), each record's department.
- * A person with several records belongs to each record's department. Nothing is guessed: a record without a
- * department adds none.
- */
-export function departmentsOfEmployees(records: readonly { active?: boolean | null; department?: { id?: string | null } | null }[] | null | undefined): string[] {
-  return [...new Set((records ?? []).filter(one => one?.active === true && one.department?.id).map(one => one.department!.id!))]
-}
-
-/**
- * A share the owner may give - a known scope with a target; the domain scope names the owner's own domain, a role one
- * of the domain's roles (`roleIds`, the ones it inherits included).
- */
-export function shareRefusal(share: CardShareRow, owner: { domainId: string; departmentsAvailable: boolean; roleIds?: readonly string[] }): string | undefined {
-  if (!['USER', 'DEPARTMENT', 'ROLE', 'DOMAIN'].includes(share.scope)) return 'unknown-scope'
-  if (!share.targetId) return 'no-target'
-  if (share.scope === 'DOMAIN' && share.targetId !== owner.domainId) return 'another-domain'
-  if (share.scope === 'DEPARTMENT' && !owner.departmentsAvailable) return 'no-departments'
-  if (share.scope === 'ROLE' && !(owner.roleIds ?? []).includes(share.targetId)) return 'unknown-role'
-  return undefined
+  return audienceReaches(shares, viewer) ? 'shared' : undefined
 }

package/server/service/card/card-resolver.ts

@@ -10,8 +10,9 @@ import { Arg, Ctx, Directive, Int, Mutation, Query, Resolver } from 'type-graphq
 import { GraphQLJSON } from 'graphql-scalars'
 import { In, IsNull, Not } from 'typeorm'
 
-import { applyDomainInheritanceFilter, getRepository, InheritedValueType } from '@things-factory/shell'
-import { Role, User } from '@things-factory/auth-base'
+import { getRepository } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { audienceMemberOf, audienceTargetRefusal, departmentTreeOf, domainRolesOf } from '@things-factory/organization'
 import {
   assertMayWriteSession,
   ChatMessage,
@@ -25,7 +26,7 @@ import {
   toolAccessFor
 } from '@things-factory/ai-assistant'
 
-import { cardAccessOf, departmentsOfEmployees, shareRefusal, type CardAccess, type CardViewer } from './card-access.js'
+import { cardAccessOf, type CardAccess, type CardViewer } from './card-access.js'
 import { CARD_SCHEMA_VERSION, checkDefinition, sourceOf, todayIn, type CardDefinition } from './card-definition.js'
 import { cardIdOf, findCardProposal } from './card-proposal.js'
 import { runCard, type CardRunResult } from './card-run.js'
@@ -46,37 +47,15 @@ function refuse(context: ResolverContext, code: string, fallback: string, option
   throw error
 }
 
-/** The viewer of a request, with the departments they belong to for sharing - asked once per request. */
 /**
- * The roles of the domain - the ones it inherits from its parent included, as its privileges are (User.getPrivilegesByDomain);
- * `holder` keeps those one person holds.
+ * The viewer of a request as an audience sees them (organization, ADR-0163 decision 2), and the departments of their own
+ * active records - the ones they may share with. Asked once per request.
  */
-async function domainRoles(context: ResolverContext, holder?: string, tx?: any): Promise<Role[]> {
-  const qb = getRepository(Role, tx).createQueryBuilder('ROLE')
-  if (holder) qb.innerJoin('ROLE.users', 'HOLDER', 'HOLDER.id = :holder', { holder })
-  applyDomainInheritanceFilter(qb, 'ROLE', context.state.domain as any, InheritedValueType.Include)
-  return await qb.orderBy('ROLE.name').getMany()
-}
-
-async function viewerOf(context: ResolverContext): Promise<{ viewer: CardViewer; departmentsAvailable: boolean; departments: { id: string; name: string }[] }> {
+async function viewerOf(context: ResolverContext): Promise<{ viewer: CardViewer; departments: { id: string; name: string }[] }> {
   const state: any = context.state
   if (state.__aiDashboardViewer) return state.__aiDashboardViewer
-  let records: any[] | undefined
-  try {
-    /* The organization module's own door, as the viewer - absent in an application without it. */
-    const answer = await runAsCaller(context)('query { myEmployees { active department { id name } } }', {})
-    if (!answer.errors?.length) records = answer.data?.myEmployees ?? []
-  } catch {
-    records = undefined
-  }
-  const departmentIds = departmentsOfEmployees(records)
-  const departments = departmentIds.map(id => ({ id, name: records!.find(one => one?.department?.id === id)?.department?.name ?? id }))
-  const roleIds = state.user?.id ? (await domainRoles(context, state.user.id)).map(one => one.id) : []
-  const answer = {
-    viewer: { userId: state.user?.id, domainId: state.domain?.id, departmentIds, roleIds },
-    departmentsAvailable: records !== undefined,
-    departments
-  }
+  const { ownDepartments, ...viewer } = await audienceMemberOf(state.domain, state.user ?? {})
+  const answer = { viewer, departments: ownDepartments }
   state.__aiDashboardViewer = answer
   return answer
 }
@@ -148,6 +127,7 @@ export async function runAsViewer(definition: CardDefinition, context: ResolverC
     passesDoor: door => toolAccessFor(context)(door),
     run: runAsCaller(context),
     today: todayIn(context.state.domain?.timezone),
+    timeZone: context.state.domain?.timezone,
     words: (key, fallback) => {
       if (!key || typeof context.t !== 'function') return fallback
       const said = context.t(key)
@@ -226,15 +206,14 @@ export class DashboardCardResolver {
   @Directive(QUERY)
   @Query(returns => DashboardShareOptions, { description: 'What the viewer may share a card with - the domain, their own departments, and whether people can be looked up.' })
   async dashboardShareOptions(@Ctx() context: ResolverContext): Promise<DashboardShareOptions> {
-    const { departmentsAvailable, departments } = await viewerOf(context)
+    const { departments } = await viewerOf(context)
     const domain: any = context.state.domain
     return {
       domainId: domain.id,
       domainName: domain.name ?? domain.subdomain ?? domain.id,
-      departmentsAvailable,
       departments,
       peopleAvailable: await toolAccessFor(context)('Query.employees'),
-      roles: (await domainRoles(context)).map(one => ({ id: one.id, name: one.name, ...(one.description ? { note: one.description } : {}) }))
+      roles: (await domainRolesOf(context.state.domain)).map(one => ({ id: one.id, name: one.name, ...(one.description ? { note: one.description } : {}) }))
     }
   }
 
@@ -381,11 +360,11 @@ export class DashboardCardResolver {
   async shareDashboardCard(@Arg('id') id: string, @Arg('shares', type => [DashboardCardShareInput]) shares: DashboardCardShareInput[], @Ctx() context: ResolverContext): Promise<DashboardCardItem> {
     const { domain, user, tx } = context.state as any
     const card = await ownCard(id, context, tx)
-    const { departmentsAvailable } = await viewerOf(context)
-    const roleIds = (shares ?? []).some(one => one.scope === DashboardCardShareScope.ROLE) ? (await domainRoles(context, undefined, tx)).map(one => one.id) : []
+    const roleIds = (shares ?? []).some(one => one.scope === DashboardCardShareScope.ROLE) ? (await domainRolesOf(domain, undefined, tx)).map(one => one.id) : []
+    const departmentIds = (shares ?? []).some(one => one.scope === DashboardCardShareScope.DEPARTMENT) ? [...(await departmentTreeOf(domain, tx)).keys()] : []
     const wanted = new Map<string, DashboardCardShareInput>()
     for (const share of shares ?? []) {
-      const refusal = shareRefusal(share, { domainId: domain.id, departmentsAvailable, roleIds })
+      const refusal = audienceTargetRefusal(share, { domainId: domain.id, departmentIds, roleIds })
       if (refusal) refuse(context, `share-${refusal}`, 'this share cannot be given ({code}).', { code: refusal })
       if (share.scope === DashboardCardShareScope.USER && share.targetId === user.id) continue
       wanted.set(`${share.scope}:${share.targetId}`, share)

package/server/service/card/card-run.ts

@@ -8,7 +8,7 @@
  *
  * Dependencies come in as arguments - tested without a server.
  */
-import { filtersOf, MAX_READ_ROWS, readCriteria, readRows, rootFieldOf, rowOf, runDetail, valueAt, type ReadColumn } from '@things-factory/ai-assistant'
+import { filtersOf, MAX_READ_ROWS, readCriteria, readRows, rootFieldOf, rowOf, runDetail, valueAt, wordOf, type ReadColumn } from '@things-factory/ai-assistant'
 
 import {
   checkDefinition,
@@ -38,6 +38,8 @@ export interface CardRunDeps {
   run: Runner
   /** Today in the domain's time zone - `YYYY-MM-DD`. */
   today: string
+  /** The domain's time zone - a moment in the rows is read in it. */
+  timeZone?: string
   /** The reader's words for a label key. */
   words?(key: string | undefined, fallback: string): string
 }
@@ -106,7 +108,9 @@ async function readSource(source: CardSource, where: Record<string, unknown>, de
     const { criteria, refused } = readCriteria(source.target!, where)
     if (refused.length) return { issue: { code: 'condition-unreadable', params: { refused } } }
     try {
-      const read = await readRows(source.target!, filtersOf(source.target!, criteria), deps.run, typeof criteria.text === 'string' && source.target!.search ? criteria.text : undefined)
+      const read = await readRows(source.target!, filtersOf(source.target!, criteria), deps.run, typeof criteria.text === 'string' && source.target!.search ? criteria.text : undefined, {
+        timeZone: deps.timeZone
+      })
       return { rows: read.rows as Row[], total: read.total, complete: read.complete }
     } catch (error: any) {
       return { issue: { code: 'query-failed', params: { message: String(error?.message ?? error) } } }
@@ -120,7 +124,7 @@ async function readSource(source: CardSource, where: Record<string, unknown>, de
   const items = at ? valueAt(ran.value, at) : ran.value
   /* An empty list is no rows; a path that holds no list is the declaration's mistake, said as such. */
   if (!Array.isArray(items)) return { issue: { code: 'list-missing', params: { read: source.key, list: source.list!.key, at } } }
-  const rows = items.slice(0, MAX_READ_ROWS).map(item => rowOf({ columns: source.columns }, item) as Row)
+  const rows = items.slice(0, MAX_READ_ROWS).map(item => rowOf({ columns: source.columns }, item, { timeZone: deps.timeZone }) as Row)
   return { rows, total: items.length, complete: items.length <= MAX_READ_ROWS }
 }
 
@@ -267,7 +271,8 @@ export async function runCard(definition: CardDefinition, deps: CardRunDeps): Pr
       block: {
         kind: 'table',
         columns: drawn.map(column => ({ name: column.name, label: label(column), type: column.type })),
-        rows: rows.map(row => Object.fromEntries(drawn.map(column => [column.name, row[column.name] ?? null])))
+        /* A coded value is shown by its word in the viewer's language; the rows were matched and sorted by the code. */
+        rows: rows.map(row => Object.fromEntries(drawn.map(column => [column.name, wordOf(column, row[column.name] ?? null, words)])))
       },
       counts,
       asOf,
@@ -283,7 +288,7 @@ export async function runCard(definition: CardDefinition, deps: CardRunDeps): Pr
     block: {
       kind: 'chart',
       chart: view.kind,
-      x: rows.map(row => String(row[x] ?? '').slice(0, 60)),
+      x: rows.map(row => String(wordOf(shaped.columns.find(one => one.name === x), row[x] ?? '', words) ?? '').slice(0, 60)),
       series: series.map(column => ({ name: label(column), values: rows.map(row => (typeof row[column.name] === 'number' ? (row[column.name] as number) : null)) })),
       ...(unitOf(series) && unitOf(series) !== 'unknown' ? { unit: unitOf(series) } : {})
     },

package/server/service/card/card-tool.ts

@@ -156,7 +156,8 @@ export async function proposeDashboardCard(args: any, context: any, deps: { run?
     detailReadOf,
     passesDoor: deps.passesDoor ?? (door => toolAccessFor(context)(door)),
     run: deps.run ?? runAsCaller(context),
-    today: deps.today ?? todayIn(context?.state?.domain?.timezone)
+    today: deps.today ?? todayIn(context?.state?.domain?.timezone),
+    timeZone: context?.state?.domain?.timezone
   })
   if (ran.issue) {
     return { rejected: true, error: ran.issue.code, ...(ran.issue.params ? { params: ran.issue.params } : {}), source: sourceSheet(source, definition.rows?.groupBy), message: 'the card could not be drawn - fix the definition and call again in this turn; say plainly if it cannot be.' }
@@ -314,23 +315,19 @@ export async function readDashboardCard(args: any, context: any, cardOf?: (id: s
 const usableInDomain =
   (context: any) =>
   async (id: string): Promise<{ card?: any; access?: string }> => {
-    const [{ getRepository }, { DashboardCard, DashboardCardShare }, { cardAccessOf, departmentsOfEmployees }] = await Promise.all([
+    const [{ getRepository }, { DashboardCard, DashboardCardShare }, { cardAccessOf }, { audienceMemberOf }] = await Promise.all([
       import('@things-factory/shell'),
       import('./dashboard-card.js'),
-      import('./card-access.js')
+      import('./card-access.js'),
+      import('@things-factory/organization')
     ])
     const domainId = context?.state?.domain?.id
     const card = await getRepository(DashboardCard).findOne({ where: { id, domain: { id: domainId } } as any })
     if (!card) return {}
     const shares = await getRepository(DashboardCardShare).find({ where: { card: { id: card.id } } as any })
-    let records: any[] | undefined
-    try {
-      const answer = await runAsCaller(context)('query { myEmployees { active department { id } } }', {})
-      records = answer.errors?.length ? [] : answer.data?.myEmployees
-    } catch {
-      records = []
-    }
-    const access = cardAccessOf(card, { userId: context?.state?.user?.id, domainId, departmentIds: departmentsOfEmployees(records) }, shares)
+    /* The same viewer the card doors see - its roles included, which this read left out until 2026-10-26. */
+    const { ownDepartments, ...viewer } = await audienceMemberOf(context?.state?.domain, context?.state?.user ?? {})
+    const access = cardAccessOf(card, viewer, shares)
     return { card, access }
   }
 

package/server/service/card/card-types.ts

@@ -107,9 +107,6 @@ export class DashboardShareOptions {
   @Field({ description: 'The domain name.' })
   domainName: string
 
-  @Field({ description: 'Whether departments are known here (the organization module).' })
-  departmentsAvailable: boolean
-
   @Field(type => [DashboardShareChoice], { description: "The viewer's own departments." })
   departments: DashboardShareChoice[]
 

package/server/service/card/card-words.test.ts

@@ -0,0 +1,72 @@
+/*
+ * A card shows people words and moments they read (ADR-0163, 2026-10-26: a card of announcements showed EVENT, unread
+ * and 2026-10-26T09:09:03.235Z) - matched and sorted by the code, drawn by the word in the viewer's language.
+ */
+import { listReadTarget } from '@things-factory/ai-assistant'
+
+import { runCard, type CardRunDeps } from './card-run'
+
+const notices = listReadTarget({
+  key: 'test.notices',
+  title: 'title.notices',
+  name: 'notices',
+  listQuery: 'notices',
+  selection: 'id title kind state publishedAt',
+  columns: [
+    { name: 'title', type: 'string' },
+    { name: 'kind', type: 'string', words: 'notice.kind.' },
+    { name: 'state', type: 'string', words: 'notice.state.' },
+    { name: 'publishedAt', type: 'date' }
+  ]
+})
+
+const items = [
+  { id: 'n1', title: '워크숍', kind: 'EVENT', state: 'unread', publishedAt: '2026-10-26T09:09:03.235Z' },
+  { id: 'n2', title: '휴무', kind: 'HR', state: 'read', publishedAt: '2026-10-25T20:00:00Z' },
+  { id: 'n3', title: '점검', kind: 'EVENT', state: 'unread', publishedAt: '2026-10-24T01:00:00Z' }
+]
+const WORDS: Record<string, string> = { 'notice.kind.HR': '인사', 'notice.kind.EVENT': '행사', 'notice.state.unread': '안 읽음', 'notice.state.read': '읽음' }
+
+const deps = (over: Partial<CardRunDeps> = {}): CardRunDeps => ({
+  readTargetOf: key => (key === notices.key ? notices : undefined),
+  detailReadOf: () => undefined,
+  passesDoor: async () => true,
+  run: async () => ({ data: { notices: { items, total: items.length } } }),
+  today: '2026-10-26',
+  /* Not this machine's zone - a run that forgot the domain's zone would read the machine's instead. */
+  timeZone: 'UTC',
+  words: (key, fallback) => (key && WORDS[key]) || fallback,
+  ...over
+})
+
+it('★ a table matched by the code shows the words and the moments in the domain\'s time', async () => {
+  const ran: any = await runCard(
+    { schemaVersion: 1, source: { read: notices.key }, rows: { match: [{ column: 'state', op: 'eq', value: 'unread' }] }, view: { kind: 'table', columns: ['title', 'kind', 'state', 'publishedAt'] } },
+    deps()
+  )
+  expect(ran.issue).toBeUndefined()
+  expect(ran.block.rows).toEqual([
+    { title: '워크숍', kind: '행사', state: '안 읽음', publishedAt: '2026-10-26 09:09' },
+    { title: '점검', kind: '행사', state: '안 읽음', publishedAt: '2026-10-24 01:00' }
+  ])
+})
+
+it('★ a chart grouped by a coded column names its bars by the words', async () => {
+  const ran: any = await runCard({ schemaVersion: 1, source: { read: notices.key }, rows: { groupBy: 'kind' }, view: { kind: 'bar', values: ['count'] } }, deps())
+  expect(ran.issue).toBeUndefined()
+  expect([...ran.block.x].sort()).toEqual(['인사', '행사'])
+})
+
+it('a viewer without the words sees the code - never nothing', async () => {
+  const ran: any = await runCard({ schemaVersion: 1, source: { read: notices.key }, view: { kind: 'table', columns: ['kind'] } }, deps({ words: undefined }))
+  expect(ran.block.rows.map((one: any) => one.kind)).toEqual(['EVENT', 'HR', 'EVENT'])
+})
+
+it('★ a moment is grouped by the month of the domain\'s time - 31 October 20:00 UTC is November in Seoul', async () => {
+  const late = [{ id: 'n9', title: '월말', kind: 'HR', state: 'read', publishedAt: '2026-10-31T20:00:00Z' }]
+  const ran: any = await runCard(
+    { schemaVersion: 1, source: { read: notices.key }, rows: { groupBy: 'publishedAt' }, view: { kind: 'bar', values: ['count'] } },
+    deps({ timeZone: 'Asia/Seoul', run: async () => ({ data: { notices: { items: late, total: 1 } } }) })
+  )
+  expect(ran.block.x).toEqual(['2026-11'])
+})

package/test/translations.test.ts

@@ -18,7 +18,7 @@ const locale = (lang: string): Record<string, string> => JSON.parse(readFileSync
 const used = new Set<string>([...text.matchAll(/'(ai-dashboard\.[a-z0-9.-]+[a-z0-9])'/g)].map(match => match[1]).filter(key => key !== 'ai-dashboard.use'))
 /* Keys built from a code: the refusals (refuse(context, '<code>', ...)), the shares' (share-<code>), the issues a card names, the views. */
 for (const [, code] of text.matchAll(/refuse\(context, '([a-z-]+)'/g)) used.add(`ai-dashboard.refusal.${code}`)
-for (const code of ['unknown-scope', 'no-target', 'another-domain', 'no-departments', 'unknown-role']) used.add(`ai-dashboard.refusal.share-${code}`)
+for (const code of ['unknown-scope', 'no-target', 'another-domain', 'unknown-department', 'unknown-role']) used.add(`ai-dashboard.refusal.share-${code}`)
 const issues = /KNOWN_ISSUES = \[([\s\S]*?)\]/.exec(text)![1]
 for (const [, code] of issues.matchAll(/'([a-z-]+)'/g)) used.add(`ai-dashboard.issue.${code}`)
 for (const view of ['number', 'table', 'bar', 'line']) used.add(`ai-dashboard.view.${view}`)

package/translations/en.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "Everyone in {name}",
   "ai-dashboard.share.everyone": "everyone",
   "ai-dashboard.share.departments": "My departments",
-  "ai-dashboard.share.department-members": "active members",
+  "ai-dashboard.share.department-members": "active members, sub-departments included",
   "ai-dashboard.share.roles": "Roles",
   "ai-dashboard.share.role-holders": "whoever holds this role",
   "ai-dashboard.share.people": "People",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "An unknown share scope.",
   "ai-dashboard.refusal.share-no-target": "The share names no one.",
   "ai-dashboard.refusal.share-another-domain": "A card cannot be shared with another site.",
-  "ai-dashboard.refusal.share-no-departments": "This application has no departments to share with.",
+  "ai-dashboard.refusal.share-unknown-department": "A card can be shared only with a department of this domain.",
   "ai-dashboard.refusal.share-unknown-role": "A card can be shared only with a role of this domain.",
   "ai-dashboard.refusal.unknown-place": "That card is not on your dashboard.",
   "ai-dashboard.refusal.size-out-of-range": "A card spans 1 to 4 columns and 1 to 2 rows.",

package/translations/es.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "Todos en {name}",
   "ai-dashboard.share.everyone": "todos",
   "ai-dashboard.share.departments": "Mis departamentos",
-  "ai-dashboard.share.department-members": "miembros activos",
+  "ai-dashboard.share.department-members": "miembros activos, subdepartamentos incluidos",
   "ai-dashboard.share.roles": "Roles",
   "ai-dashboard.share.role-holders": "quien tenga este rol",
   "ai-dashboard.share.people": "Personas",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "Un ámbito de uso compartido desconocido.",
   "ai-dashboard.refusal.share-no-target": "El uso compartido no nombra a nadie.",
   "ai-dashboard.refusal.share-another-domain": "No se puede compartir una tarjeta con otro sitio.",
-  "ai-dashboard.refusal.share-no-departments": "Esta aplicación no tiene departamentos con los que compartir.",
+  "ai-dashboard.refusal.share-unknown-department": "Solo se puede compartir con un departamento de este dominio.",
   "ai-dashboard.refusal.share-unknown-role": "Solo se puede compartir con un rol de este dominio.",
   "ai-dashboard.refusal.unknown-place": "Esa tarjeta no está en su panel.",
   "ai-dashboard.refusal.size-out-of-range": "Una tarjeta ocupa de 1 a 4 columnas y de 1 a 2 filas.",

package/translations/ja.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "{name} 全員",
   "ai-dashboard.share.everyone": "事業所全員",
   "ai-dashboard.share.departments": "自分の部署",
-  "ai-dashboard.share.department-members": "在籍中の部署員",
+  "ai-dashboard.share.department-members": "在籍中の部署員(下位部署を含む)",
   "ai-dashboard.share.roles": "ロール",
   "ai-dashboard.share.role-holders": "このロールを持つ人",
   "ai-dashboard.share.people": "人",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "不明な共有範囲です。",
   "ai-dashboard.refusal.share-no-target": "共有の対象がありません。",
   "ai-dashboard.refusal.share-another-domain": "他の事業所には共有できません。",
-  "ai-dashboard.refusal.share-no-departments": "このアプリには部署がないため、部署に共有できません。",
+  "ai-dashboard.refusal.share-unknown-department": "この事業所にない部署には共有できません。",
   "ai-dashboard.refusal.share-unknown-role": "この事業所にないロールには共有できません。",
   "ai-dashboard.refusal.unknown-place": "そのカードはダッシュボードにありません。",
   "ai-dashboard.refusal.size-out-of-range": "カードは横1〜4列、縦1〜2行です。",

package/translations/ko.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "{name} 전체",
   "ai-dashboard.share.everyone": "사업장 전체",
   "ai-dashboard.share.departments": "내 부서",
-  "ai-dashboard.share.department-members": "재직 중인 부서원",
+  "ai-dashboard.share.department-members": "재직 중인 부서원(하위 부서 포함)",
   "ai-dashboard.share.roles": "역할",
   "ai-dashboard.share.role-holders": "이 역할을 가진 사람",
   "ai-dashboard.share.people": "사람",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "알 수 없는 공유 범위입니다.",
   "ai-dashboard.refusal.share-no-target": "공유할 대상이 없습니다.",
   "ai-dashboard.refusal.share-another-domain": "다른 사업장에는 공유할 수 없습니다.",
-  "ai-dashboard.refusal.share-no-departments": "이 앱에는 부서가 없어 부서로 공유할 수 없습니다.",
+  "ai-dashboard.refusal.share-unknown-department": "이 사업장에 없는 부서에는 공유할 수 없습니다.",
   "ai-dashboard.refusal.share-unknown-role": "사업장에 없는 역할에는 공유할 수 없습니다.",
   "ai-dashboard.refusal.unknown-place": "그 카드는 대시보드에 없습니다.",
   "ai-dashboard.refusal.size-out-of-range": "카드는 가로 1~4칸, 세로 1~2줄입니다.",

package/translations/ms.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "Semua dalam {name}",
   "ai-dashboard.share.everyone": "semua",
   "ai-dashboard.share.departments": "Jabatan saya",
-  "ai-dashboard.share.department-members": "ahli aktif",
+  "ai-dashboard.share.department-members": "ahli aktif, termasuk sub-jabatan",
   "ai-dashboard.share.roles": "Peranan",
   "ai-dashboard.share.role-holders": "sesiapa yang memegang peranan ini",
   "ai-dashboard.share.people": "Orang",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "Skop perkongsian tidak diketahui.",
   "ai-dashboard.refusal.share-no-target": "Perkongsian tidak menamakan sesiapa.",
   "ai-dashboard.refusal.share-another-domain": "Kad tidak boleh dikongsi dengan tapak lain.",
-  "ai-dashboard.refusal.share-no-departments": "Aplikasi ini tiada jabatan untuk dikongsi.",
+  "ai-dashboard.refusal.share-unknown-department": "Kad hanya boleh dikongsi dengan jabatan dalam domain ini.",
   "ai-dashboard.refusal.share-unknown-role": "Kad hanya boleh dikongsi dengan peranan dalam domain ini.",
   "ai-dashboard.refusal.unknown-place": "Kad itu tiada pada papan pemuka anda.",
   "ai-dashboard.refusal.size-out-of-range": "Kad merangkumi 1 hingga 4 lajur dan 1 hingga 2 baris.",

package/translations/zh.json

@@ -49,7 +49,7 @@
   "ai-dashboard.share.everyone-in": "{name} 全体",
   "ai-dashboard.share.everyone": "全体",
   "ai-dashboard.share.departments": "我的部门",
-  "ai-dashboard.share.department-members": "在职部门成员",
+  "ai-dashboard.share.department-members": "在职部门成员(含下级部门)",
   "ai-dashboard.share.roles": "角色",
   "ai-dashboard.share.role-holders": "拥有此角色的人",
   "ai-dashboard.share.people": "人员",
@@ -116,7 +116,7 @@
   "ai-dashboard.refusal.share-unknown-scope": "未知的共享范围。",
   "ai-dashboard.refusal.share-no-target": "共享没有指定对象。",
   "ai-dashboard.refusal.share-another-domain": "不能共享到其他业务单位。",
-  "ai-dashboard.refusal.share-no-departments": "此应用没有部门,无法按部门共享。",
+  "ai-dashboard.refusal.share-unknown-department": "只能共享给本域中的部门。",
   "ai-dashboard.refusal.share-unknown-role": "只能共享给本域中的角色。",
   "ai-dashboard.refusal.unknown-place": "该卡片不在您的仪表板上。",
   "ai-dashboard.refusal.size-out-of-range": "卡片横跨1至4列、1至2行。",