@csntgao/uni-base 0.1.0

package/packages/core/tests/notification-center-client.test.ts

@@ -0,0 +1,467 @@
+import { describe, expect, it, vi } from 'vitest'
+import { NotificationCenterClient } from '../src/notification-center-client'
+import type {
+  NotificationCenterTransport,
+  NotificationDto,
+  NotificationRealtimeChange,
+  NotificationTypeSummary,
+} from '../src/notification-center-types'
+
+function notification(overrides: Partial<NotificationDto> = {}): NotificationDto {
+  return {
+    id: overrides.id ?? 'n1',
+    type: overrides.type ?? 'report',
+    typeName: overrides.typeName ?? '',
+    title: overrides.title ?? '5月人事月报已生成',
+    summary: overrides.summary ?? '含在职、入离职、合规、薪酬',
+    content: overrides.content ?? '正文',
+    contentType: overrides.contentType ?? 'text',
+    priority: overrides.priority ?? 'normal',
+    source: overrides.source ?? {
+      type: 'ai_employee',
+      code: 'archive',
+      id: '',
+      name: '数据分析师',
+      avatarUrl: '',
+    },
+    resources: overrides.resources ?? [],
+    attachments: overrides.attachments ?? [],
+    readStatus: overrides.readStatus ?? 'unread',
+    readAt: overrides.readAt ?? null,
+    archivedAt: overrides.archivedAt ?? null,
+    createdAt: overrides.createdAt ?? '2026-05-30T16:35:00.000Z',
+    expiresAt: overrides.expiresAt ?? null,
+  }
+}
+
+function baseTransport(overrides: Partial<NotificationCenterTransport> = {}): {
+  transport: NotificationCenterTransport
+  inbox: ReturnType<typeof vi.fn>
+  unread: ReturnType<typeof vi.fn>
+  markRead: ReturnType<typeof vi.fn>
+  markAllRead: ReturnType<typeof vi.fn>
+} {
+  const inbox = vi.fn(async () => ({ items: [notification()], hasMore: false, nextId: null }))
+  const unread = vi.fn(async () => ({ unreadCount: 3 }))
+  const markRead = vi.fn(async () => ({ unreadCount: 2, readAt: '2026-05-30T17:00:00.000Z' }))
+  const markAllRead = vi.fn(async () => ({ markedCount: 3, unreadCount: 0 }))
+  const transport: NotificationCenterTransport = {
+    listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    getUnreadCount: unread as unknown as NotificationCenterTransport['getUnreadCount'],
+    markRead: markRead as unknown as NotificationCenterTransport['markRead'],
+    markAllRead: markAllRead as unknown as NotificationCenterTransport['markAllRead'],
+    downloadAttachment: vi.fn(async () => new Blob(['x'])),
+    ...overrides,
+  }
+  return { transport, inbox, unread, markRead, markAllRead }
+}
+
+const flush = () => new Promise((resolve) => setTimeout(resolve, 0))
+
+describe('NotificationCenterClient', () => {
+  it('loads inbox + unread with applicationName in the request body and never opens a socket', async () => {
+    const { transport, inbox, unread } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    const ready = vi.fn()
+    const unreadEvents: number[] = []
+    client.on('ready', ready)
+    client.on('unread-count-change', ({ unreadCount }) => unreadEvents.push(unreadCount))
+    await client.start()
+
+    expect(inbox).toHaveBeenCalledWith(
+      expect.objectContaining({ pageSize: 20, beforeId: null, applicationName: 'HrSaas' }),
+    )
+    expect(unread).toHaveBeenCalledWith({ applicationName: 'HrSaas' })
+    expect(client.notifications).toHaveLength(1)
+    expect(unreadEvents).toContain(3)
+    expect(ready).toHaveBeenCalledTimes(1)
+    // The client owns no realtime connection: it never asks for a token or a socket.
+    expect(Object.keys(transport)).not.toContain('getAccessToken')
+    expect('connectionState' in client).toBe(false)
+    client.destroy()
+  })
+
+  it('rejects construction without a transport', () => {
+    expect(
+      () =>
+        new NotificationCenterClient({
+          transport: undefined as unknown as NotificationCenterTransport,
+          applicationName: 'HrSaas',
+        }),
+    ).toThrow(/transport/)
+  })
+
+  it('uses an empty applicationName as the all-applications projection', async () => {
+    const { transport, inbox, unread } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: '   ' })
+    await client.start()
+
+    expect(inbox).toHaveBeenCalledWith(expect.objectContaining({ applicationName: '' }))
+    expect(unread).toHaveBeenCalledWith({ applicationName: '' })
+    client.destroy()
+  })
+
+  it('applies type filter through listInbox notification_types', async () => {
+    const { transport, inbox } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    await client.setTypeFilter(['alert'])
+    expect(inbox).toHaveBeenLastCalledWith(
+      expect.objectContaining({ notificationTypes: ['alert'], beforeId: null }),
+    )
+    expect(client.getTypeFilter()).toEqual(['alert'])
+    client.destroy()
+  })
+
+  it('supports an unread-only inbox projection for compact consumers', async () => {
+    const { transport, inbox } = baseTransport()
+    const client = new NotificationCenterClient({
+      transport,
+      applicationName: 'OfficialWebsite',
+      pageSize: 4,
+      readStatus: 'unread',
+    })
+    await client.start()
+    expect(inbox).toHaveBeenCalledWith(
+      expect.objectContaining({
+        pageSize: 4,
+        beforeId: null,
+        readStatus: 'unread',
+        applicationName: 'OfficialWebsite',
+      }),
+    )
+    client.destroy()
+  })
+
+  it('derives the type catalog from loaded pages when the backend sends no facets', async () => {
+    const inbox = vi.fn(async () => ({
+      items: [
+        notification({ id: 'n1', type: 'report', typeName: '报告' }),
+        notification({ id: 'n2', type: 'alert', typeName: '预警' }),
+        // 后端字典缺该码的展示名时保留空串，由 UI 回退到 code。
+        notification({ id: 'n3', type: 'interview', typeName: '' }),
+        notification({ id: 'n4', type: 'alert', typeName: '预警' }),
+      ],
+      hasMore: false,
+      nextId: null,
+    }))
+    const { transport } = baseTransport({
+      listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    const emitted: NotificationTypeSummary[][] = []
+    client.on('types-change', ({ types }) => emitted.push([...types]))
+    await client.start()
+    expect(client.types).toEqual([
+      { type: 'report', name: '报告' },
+      { type: 'alert', name: '预警' },
+      { type: 'interview', name: '' },
+    ])
+    expect(emitted.at(-1)).toEqual(client.types)
+    client.destroy()
+  })
+
+  it('requests inbox type facets and prefers them over page-local types', async () => {
+    const inbox = vi.fn(async () => ({
+      items: [notification({ id: 'n1', type: 'report', typeName: '报告' })],
+      hasMore: false,
+      nextId: null,
+      types: [
+        { type: 'care', name: '关怀' },
+        { type: 'sales_lead_assigned', name: '新线索' },
+        { type: 'todo', name: '待办' },
+      ],
+    }))
+    const { transport } = baseTransport({
+      listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    // 目录随 inbox 同一请求取回，不额外发请求。
+    expect(inbox).toHaveBeenCalledTimes(1)
+    expect(inbox).toHaveBeenCalledWith(expect.objectContaining({ includeTypeFacets: true }))
+    // 后端目录为权威：顺序照搬，且不并入仅在当前页出现的 report。
+    expect(client.types).toEqual([
+      { type: 'care', name: '关怀' },
+      { type: 'sales_lead_assigned', name: '新线索' },
+      { type: 'todo', name: '待办' },
+    ])
+    client.destroy()
+  })
+
+  it('fills a missing catalog display name from the loaded items', async () => {
+    const inbox = vi.fn(async () => ({
+      items: [notification({ id: 'n1', type: 'report', typeName: '报告' })],
+      hasMore: false,
+      nextId: null,
+      types: [{ type: 'report', name: '' }],
+    }))
+    const { transport } = baseTransport({
+      listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    expect(client.types).toEqual([{ type: 'report', name: '报告' }])
+    client.destroy()
+  })
+
+  it('keeps discovered types after a filtered reload and honours preferredTypeOrder', async () => {
+    let filtered = false
+    const inbox = vi.fn(async (query: { notificationTypes?: readonly string[] }) => {
+      filtered = (query.notificationTypes ?? []).length > 0
+      const items = filtered
+        ? [notification({ id: 'n2', type: 'alert' })]
+        : [notification({ id: 'n1', type: 'report' }), notification({ id: 'n2', type: 'alert' })]
+      return { items, hasMore: false, nextId: null }
+    })
+    const { transport } = baseTransport({
+      listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({
+      transport,
+      applicationName: 'HrSaas',
+      preferredTypeOrder: ['alert'],
+    })
+    await client.start()
+    // preferredTypeOrder 把 alert 顶到最前，其余按发现顺序。
+    expect(client.types.map((entry) => entry.type)).toEqual(['alert', 'report'])
+    await client.setTypeFilter(['alert'])
+    // 服务端只回 alert，但目录不得塌缩成单个分类。
+    expect(filtered).toBe(true)
+    expect(client.types.map((entry) => entry.type)).toEqual(['alert', 'report'])
+    client.destroy()
+  })
+
+  it('registers a brand-new type arriving through a host-fed created event', async () => {
+    const parseRealtimeEvent = vi.fn((): NotificationRealtimeChange => ({
+      kind: 'created',
+      notification: notification({ id: 'n9', type: 'interview' }),
+      unreadCount: 4,
+    }))
+    const { transport } = baseTransport({ parseRealtimeEvent })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    expect(client.types.map((entry) => entry.type)).toEqual(['report'])
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+    expect(client.types.map((entry) => entry.type)).toEqual(['report', 'interview'])
+    client.destroy()
+  })
+
+  it('marks a single notification read and updates unread count', async () => {
+    const { transport, markRead } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    const readEvents: string[] = []
+    const unreadEvents: number[] = []
+    client.on('notification-read', ({ notificationId }) => readEvents.push(notificationId))
+    client.on('unread-count-change', ({ unreadCount }) => unreadEvents.push(unreadCount))
+    await client.start()
+    await client.markRead('n1')
+    expect(markRead).toHaveBeenCalledWith({ notificationId: 'n1', applicationName: 'HrSaas' })
+    expect(client.notifications[0]?.readStatus).toBe('read')
+    expect(readEvents).toEqual(['n1'])
+    expect(unreadEvents).toContain(2)
+    client.destroy()
+  })
+
+  it('marks all read and zeroes the unread count', async () => {
+    const { transport, markAllRead } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    await client.markAllRead()
+    expect(markAllRead).toHaveBeenCalledWith({ applicationName: 'HrSaas' })
+    expect(client.notifications.every((item) => item.readStatus === 'read')).toBe(true)
+    expect(client.unread).toBe(0)
+    client.destroy()
+  })
+
+  it('inserts a host-fed created event in place via parseRealtimeEvent', async () => {
+    const parseRealtimeEvent = vi.fn((): NotificationRealtimeChange => ({
+      kind: 'created',
+      notification: notification({ id: 'n2', title: '新预警', type: 'alert' }),
+      unreadCount: 4,
+    }))
+    const { transport, inbox } = baseTransport({ parseRealtimeEvent })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    inbox.mockClear()
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+
+    expect(parseRealtimeEvent).toHaveBeenCalledWith({ event_type: 'notification_created' })
+    expect(client.notifications[0]?.id).toBe('n2')
+    expect(client.unread).toBe(4)
+    // An in-place change does not trigger another inbox round trip.
+    expect(inbox).not.toHaveBeenCalled()
+    client.destroy()
+  })
+
+  it('refreshes the aggregate unread count for all-applications realtime events', async () => {
+    const parseRealtimeEvent = vi.fn((): NotificationRealtimeChange => ({
+      kind: 'created',
+      notification: notification({ id: 'n2' }),
+      // Existing realtime payloads are application-scoped and cannot replace
+      // the aggregate count used when applicationName is empty.
+      unreadCount: 99,
+    }))
+    const { transport, unread } = baseTransport({ parseRealtimeEvent })
+    const client = new NotificationCenterClient({ transport, applicationName: '' })
+    await client.start()
+    unread.mockClear()
+
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+    await flush()
+
+    expect(unread).toHaveBeenCalledWith({ applicationName: '' })
+    expect(client.unread).toBe(3)
+    client.destroy()
+  })
+
+  it('deduplicates a host-fed created event by notification id', async () => {
+    const parseRealtimeEvent = vi.fn((): NotificationRealtimeChange => ({
+      kind: 'created',
+      notification: notification({ id: 'n1' }),
+      unreadCount: 3,
+    }))
+    const { transport } = baseTransport({ parseRealtimeEvent })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+    expect(client.notifications).toHaveLength(1)
+    client.destroy()
+  })
+
+  it('applies host-fed read and archived events', async () => {
+    let change: NotificationRealtimeChange = {
+      kind: 'read',
+      notificationIds: ['n1'],
+      unreadCount: 0,
+      readAt: '2026-05-30T18:00:00.000Z',
+    }
+    const { transport } = baseTransport({ parseRealtimeEvent: () => change })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    client.applyRealtimeEvent({})
+    expect(client.notifications[0]?.readStatus).toBe('read')
+    expect(client.unread).toBe(0)
+
+    change = { kind: 'archived', notificationIds: ['n1'], unreadCount: 0 }
+    client.applyRealtimeEvent({})
+    expect(client.notifications).toHaveLength(0)
+    client.destroy()
+  })
+
+  it('falls back to a full refresh when the event cannot be mapped', async () => {
+    const { transport, inbox, unread } = baseTransport({ parseRealtimeEvent: () => null })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    inbox.mockClear()
+    unread.mockClear()
+    client.applyRealtimeEvent({ event_type: 'notification_unknown' })
+    await flush()
+    expect(inbox).toHaveBeenCalledTimes(1)
+    expect(unread).toHaveBeenCalledTimes(1)
+    client.destroy()
+  })
+
+  it('falls back to a full refresh when parseRealtimeEvent throws or is absent', async () => {
+    const throwing = baseTransport({
+      parseRealtimeEvent: () => {
+        throw new Error('bad event')
+      },
+    })
+    const client = new NotificationCenterClient({
+      transport: throwing.transport,
+      applicationName: 'HrSaas',
+    })
+    await client.start()
+    throwing.inbox.mockClear()
+    client.applyRealtimeEvent({})
+    await flush()
+    expect(throwing.inbox).toHaveBeenCalledTimes(1)
+    client.destroy()
+
+    const plain = baseTransport()
+    const second = new NotificationCenterClient({
+      transport: plain.transport,
+      applicationName: 'HrSaas',
+    })
+    await second.start()
+    plain.inbox.mockClear()
+    second.applyRealtimeEvent({})
+    await flush()
+    expect(plain.inbox).toHaveBeenCalledTimes(1)
+    second.destroy()
+  })
+
+  it('resyncs instead of losing an event that arrives while the inbox is in flight', async () => {
+    let release = (): void => {}
+    const gate = new Promise<void>((resolve) => {
+      release = resolve
+    })
+    let firstCall = true
+    const parseRealtimeEvent = vi.fn((): NotificationRealtimeChange => ({
+      kind: 'created',
+      notification: notification({ id: 'n2' }),
+      unreadCount: 4,
+    }))
+    const inbox = vi.fn(async () => {
+      if (firstCall) {
+        firstCall = false
+        await gate
+      }
+      return { items: [notification()], hasMore: false, nextId: null }
+    })
+    const { transport } = baseTransport({
+      parseRealtimeEvent,
+      listInbox: inbox as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    const starting = client.start()
+    await flush()
+    // The event lands mid-request: applying it in place would be clobbered by the
+    // pending server page, so it is deferred into a resync instead.
+    client.applyRealtimeEvent({ event_type: 'notification_created' })
+    expect(parseRealtimeEvent).not.toHaveBeenCalled()
+    release()
+    await starting
+    await flush()
+    expect(inbox).toHaveBeenCalledTimes(2)
+    client.destroy()
+  })
+
+  it('ignores host-fed events after destroy without throwing', async () => {
+    const { transport, inbox } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    client.destroy()
+    inbox.mockClear()
+    expect(() => client.applyRealtimeEvent({ event_type: 'notification_created' })).not.toThrow()
+    await flush()
+    expect(inbox).not.toHaveBeenCalled()
+  })
+
+  it('surfaces a recoverable error when the inbox request fails', async () => {
+    const { transport } = baseTransport({
+      listInbox: vi.fn(async () => {
+        throw new Error('backend stack trace 5xx')
+      }) as unknown as NotificationCenterTransport['listInbox'],
+    })
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    const errors: Array<{ code: string; recoverable: boolean; message: string }> = []
+    client.on('error', (detail) => errors.push(detail))
+    await client.start()
+    expect(errors[0]?.code).toBe('INBOX_LOAD_FAILED')
+    expect(errors[0]?.recoverable).toBe(true)
+    // The raw backend error never reaches the surfaced detail.
+    expect(JSON.stringify(errors)).not.toContain('backend stack trace')
+    client.destroy()
+  })
+
+  it('throws when used after destroy', async () => {
+    const { transport } = baseTransport()
+    const client = new NotificationCenterClient({ transport, applicationName: 'HrSaas' })
+    await client.start()
+    client.destroy()
+    await expect(client.markRead('n1')).rejects.toThrow(/销毁/)
+  })
+})

package/packages/core/tests/protocol.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from 'vitest'
+import { createAuthenticateFrame, createSubscriptionFrame, parseAiEmployeeEvent } from '../src'
+
+describe('Kanban user realtime protocol', () => {
+  it('creates a JWT authentication first frame without identity claims', () => {
+    expect(createAuthenticateFrame('secret-jwt')).toEqual({
+      type: 'authenticate',
+      protocol_version: 1,
+      access_token: 'secret-jwt',
+      requested_channels: ['ai_employee'],
+      cursors: {},
+    })
+    expect(JSON.stringify(createAuthenticateFrame('secret-jwt'))).not.toContain('org_id')
+    expect(JSON.stringify(createAuthenticateFrame('secret-jwt'))).not.toContain('user_id')
+  })
+
+  it('creates the session subscription used after realtime_ready', () => {
+    expect(createSubscriptionFrame('session-1')).toEqual({
+      action: 'subscribe',
+      channel: 'ai_employee',
+      resource_type: 'session',
+      resource_id: 'session-1',
+      replay_history: false,
+    })
+  })
+
+  it('parses AI text patches, processing markers, results and title events', () => {
+    const parsed = parseAiEmployeeEvent({
+      type: 'session_message',
+      session_id: 'session-1',
+      payload: {
+        Ready: true,
+        JsonPatch: [
+          {
+            op: 'add',
+            path: '/0',
+            value: {
+              ws_message_id: 'message-1',
+              entry_type: { type: 'assistant_message' },
+              content: JSON.stringify({ text: '你好' }),
+              timestamp: '2026-08-03T01:00:00.000Z',
+            },
+          },
+          {
+            op: 'add',
+            path: '/1',
+            value: {
+              entry_type: { type: 'thinking' },
+              content: JSON.stringify({ thinking: 'internal' }),
+            },
+          },
+        ],
+      },
+    })
+
+    expect(parsed).toMatchObject({
+      kind: 'session-message',
+      sessionId: 'session-1',
+      result: {
+        processing: true,
+        messages: [{ id: 'message-1', role: 'assistant', content: '你好' }],
+      },
+    })
+    expect(
+      parseAiEmployeeEvent({
+        type: 'session_title_updated',
+        session_id: 'session-1',
+        payload: { title: '招聘助手' },
+      }),
+    ).toEqual({ kind: 'session-title', sessionId: 'session-1', title: '招聘助手' })
+  })
+
+  it('never exposes a backend error body as chat content', () => {
+    const parsed = parseAiEmployeeEvent({
+      type: 'session_message',
+      session_id: 'session-1',
+      payload: { error: 'Traceback: access_token=secret-jwt' },
+    })
+    expect(JSON.stringify(parsed)).not.toContain('secret-jwt')
+    expect(JSON.stringify(parsed)).not.toContain('Traceback')
+  })
+
+  it('keeps a top-level result separate as an assistant fallback', () => {
+    const parsed = parseAiEmployeeEvent({
+      type: 'session_message',
+      session_id: 'session-1',
+      payload: { result: '兜底回复' },
+    })
+
+    expect(parsed).toMatchObject({
+      kind: 'session-message',
+      sessionId: 'session-1',
+      result: {
+        messages: [],
+        fallbackResult: { role: 'assistant', content: '兜底回复' },
+      },
+    })
+  })
+
+  it('uses the database message id for user messages when realtime also supplies a frame id', () => {
+    const parsed = parseAiEmployeeEvent({
+      type: 'session_message',
+      session_id: 'atomic-session',
+      payload: {
+        JsonPatch: [
+          {
+            path: '/0',
+            value: {
+              message_id: '107021',
+              ws_message_id: '0d3805dd-d2d0-49ed-b335-e5eeec7fc3f9',
+              entry_type: { type: 'user_message' },
+              content: JSON.stringify({ text: '原子首条消息' }),
+            },
+          },
+        ],
+      },
+    })
+
+    expect(parsed).toMatchObject({
+      kind: 'session-message',
+      result: { messages: [{ id: '107021', role: 'user', content: '原子首条消息' }] },
+    })
+  })
+})

package/packages/core/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true
+  },
+  "include": ["src", "tests", "tsup.config.ts"]
+}

package/packages/core/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  target: 'es2022',
+  treeshake: true,
+})

package/packages/web-components/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@uniplat/ai-employee-web-components",
+  "version": "0.23.3",
+  "description": "Framework-independent Web Components for Uniplat account, login, application switching and AI Employee chat",
+  "type": "module",
+  "sideEffects": true,
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup && pnpm build:runtime",
+    "build:runtime": "tsup --config tsup.runtime.config.ts && node scripts/verify-runtime-build.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@uniplat/ai-employee-client": "workspace:*",
+    "lit": "^3.3.1"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}