@lincyaw/addon-session 0.0.0-stage → 1.0.0-rc.1

package/src/client/index.ts

@@ -0,0 +1,4 @@
+export { createClassroomConnection } from './classroom-connection.ts'
+export type { ClassroomConnection, ClassroomConnectionOptions } from './classroom-connection.ts'
+export { useClassroomSession } from './composables.ts'
+export { sessionPlugin } from './plugin.ts'

package/src/client/membership-storage.ts

@@ -0,0 +1,75 @@
+import type { Participant } from '@lincyaw/kernel'
+import type { FollowMode } from '../domain/index.ts'
+
+export interface Membership {
+  server: string
+  room: string
+  me: Participant
+  key: string
+  claim?: string
+  follow?: FollowMode
+  at?: number
+}
+
+export function tryStorage<T>(access: () => T): T | undefined {
+  try {
+    return access()
+  } catch {
+    return undefined
+  }
+}
+
+export interface MembershipStorageOptions {
+  /** The key prefix: one per deck. */
+  prefix: string
+  /** Where memberships are kept for every tab (localStorage). */
+  storage?: Storage
+  /** Where this tab keeps the room it is in (sessionStorage). */
+  tabStorage?: Storage
+  /** The classroom server memberships are kept for; others are not found. */
+  server: () => string | undefined
+}
+
+export interface MembershipStorage {
+  isUsable(value: Membership | null | undefined): value is Membership
+  find(room: string): Membership | undefined
+  /** The room this tab was last in. */
+  findInTab(): Membership | undefined
+  /** The presenter's membership this browser joined last, of `room` when given. */
+  findLastPresenterMembership(room?: string): Membership | undefined
+  remember(membership: Membership): void
+  forget(room: string): void
+}
+
+export function createMembershipStorage(options: MembershipStorageOptions): MembershipStorage {
+  const { prefix, storage, tabStorage } = options
+  const isUsable = (value: Membership | null | undefined): value is Membership =>
+    Boolean(value && value.server === options.server() && value.room && value.me?.id && value.key)
+  const find = (room: string) => tryStorage(() => {
+    const value = JSON.parse(storage?.getItem(`${prefix}:${room}`) ?? 'null') as Membership | null
+    return isUsable(value) ? value : undefined
+  })
+  return {
+    isUsable,
+    find,
+    findInTab() {
+      const room = tryStorage(() => tabStorage?.getItem(prefix))
+      return room ? find(room) : undefined
+    },
+    findLastPresenterMembership(room) {
+      const keys = tryStorage(() => Array.from({ length: storage?.length ?? 0 }, (_, i) => storage!.key(i) ?? '')) ?? []
+      const rooms = room ? [room] : keys.filter(key => key.startsWith(`${prefix}:`)).map(key => key.slice(prefix.length + 1))
+      return rooms.map(find)
+        .filter((value): value is Membership => value?.me.role === 'presenter' && value.claim !== undefined)
+        .sort((a, b) => (b.at ?? 0) - (a.at ?? 0))[0]
+    },
+    remember(membership) {
+      tryStorage(() => storage?.setItem(`${prefix}:${membership.room}`, JSON.stringify(membership)))
+      tryStorage(() => tabStorage?.setItem(prefix, membership.room))
+    },
+    forget(room) {
+      tryStorage(() => storage?.removeItem(`${prefix}:${room}`))
+      if (tryStorage(() => tabStorage?.getItem(prefix)) === room) tryStorage(() => tabStorage?.removeItem(prefix))
+    },
+  }
+}

package/src/client/plugin.ts

@@ -0,0 +1,88 @@
+import { currentLocale, NAVIGATION, pluginRoutePath, siteBase, SYNC_TRANSPORTS, TOOLBAR, serverClient } from '@lincyaw/host'
+import { CLASSROOM_STORE, isRecord, PRESENTER_PANELS, SESSION } from '@lincyaw/kernel'
+import type { PluginDefinition, Unsubscribe } from '@lincyaw/kernel'
+import { version } from '../../package.json'
+import { localServer, MESSAGES, reachableServer, SESSION_ID, toSessionConfig } from '../domain/index.ts'
+import type { LocalClassroom } from '../domain/index.ts'
+import { createClassroomConnection } from './classroom-connection.ts'
+import { tryStorage } from './membership-storage.ts'
+import SessionPanel from './SessionPanel.tsx'
+import SessionToolbar from './SessionToolbar.tsx'
+
+let cleanup: Unsubscribe[] = []
+
+const SERVER_WAIT_MS = 5000
+
+async function fetchLocalServer(): Promise<{ server: string, params: Record<string, string> } | undefined> {
+  let client = serverClient()
+  const available = client.available || await new Promise<boolean>((resolve) => {
+    const timer = setTimeout(() => done(false), SERVER_WAIT_MS)
+    const poll = setInterval(() => { client = serverClient(); if (client.available) done(true) }, 50)
+    const stop = () => clearInterval(poll)
+    function done(ready: boolean) {
+      clearTimeout(timer)
+      stop()
+      resolve(ready)
+    }
+  })
+  if (!available) return undefined
+  const response = await client.fetch(SESSION_ID, 'classroom').catch(() => undefined)
+  const answer: unknown = response?.ok ? await response.json().catch(() => undefined) : undefined
+  if (!isRecord(answer) || typeof answer.path !== 'string' || typeof answer.document !== 'string') return undefined
+  // The server names its route from its own root; the page reaches it below the root it was served at.
+  const own = `/__presmium/${SESSION_ID}/`
+  const path = answer.path.startsWith(own) ? `${pluginRoutePath(client, SESSION_ID)}${answer.path.slice(own.length)}` : answer.path
+  return localServer({ ...answer, path } as unknown as LocalClassroom, location)
+}
+
+export const sessionPlugin: PluginDefinition = {
+  manifest: {
+    id: SESSION_ID,
+    name: { 'zh-CN': '课堂同步', en: 'Classroom Sync' },
+    version,
+    kernel: '^1.0.0',
+    provides: [SESSION, CLASSROOM_STORE],
+    requires: [NAVIGATION, TOOLBAR, PRESENTER_PANELS, SYNC_TRANSPORTS].map(token => ({ token, optional: true })),
+    capabilities: ['network'],
+  },
+  setup(ctx) {
+    const { server } = toSessionConfig(ctx.config)
+    const connection = createClassroomConnection({
+      server: server && reachableServer(server, location.hostname),
+      navigation: ctx.tryGet(NAVIGATION),
+      base: new URL(siteBase(), location.href).href,
+      storage: tryStorage(() => window.localStorage),
+      tabStorage: tryStorage(() => window.sessionStorage),
+    })
+    ctx.provide(SESSION, connection.session)
+    ctx.provide(CLASSROOM_STORE, connection.store)
+    const title = MESSAGES[currentLocale()].classroom
+    let disposed = false
+    const show = () => [
+      // The toolbar button also mounts the learner's badge, once per page (SessionOverlays).
+      ctx.tryGet(TOOLBAR)?.register({ id: SESSION_ID, title, component: SessionToolbar }),
+      ctx.tryGet(PRESENTER_PANELS)?.register({ id: SESSION_ID, title, component: SessionPanel, order: 10 }),
+    ]
+    cleanup = [connection.dispose, ctx.tryGet(SYNC_TRANSPORTS)?.add(connection.transport)].filter(stop => stop !== undefined)
+    if (server !== undefined) {
+      cleanup.push(...show().filter(stop => stop !== undefined))
+      void connection.resume(location.search)
+      return
+    }
+    void fetchLocalServer().then((local) => {
+      if (disposed) return
+      if (local) connection.setServer(local.server, local.params)
+      if (local || import.meta.env.DEV) cleanup.push(...show().filter(stop => stop !== undefined))
+      return connection.resume(location.search)
+    })
+    cleanup.push(() => {
+      disposed = true
+    })
+  },
+  dispose() {
+    cleanup.forEach(stop => stop())
+    cleanup = []
+  },
+}
+
+export default sessionPlugin

package/src/client/sync-channels.ts

@@ -0,0 +1,71 @@
+import type { SyncTransport } from '@lincyaw/host'
+import type * as Y from 'yjs'
+import { jsonClone } from '../domain/index.ts'
+import { channel, observe, writeChannel } from './ydoc.ts'
+
+interface Link {
+  receive(patch: Record<string, unknown>): void
+  state: Readonly<Record<string, unknown>>
+}
+
+export interface SyncChannelRoles {
+  /** This window takes the presenter's state of the channels. */
+  following(): boolean
+  /** This window writes its state of the channels for the others. */
+  publishing(): boolean
+}
+
+/** The host's sync channels (shared state) carried through the classroom document. */
+export interface SyncChannels {
+  transport: SyncTransport
+  /** Observes the channels of the current document. */
+  rebind(): void
+  /** Gives a following window the presenter's state of every channel. */
+  deliver(): void
+  /** Writes this window's state of every channel. */
+  publishAll(): void
+}
+
+export function createSyncChannels(doc: () => Y.Doc, roles: SyncChannelRoles): SyncChannels {
+  const links = new Map<string, Link>()
+  let detach: (() => void)[] = []
+
+  function attach(name: string, link: Link): void {
+    const map = channel(doc(), name)
+    detach.push(observe(map, (event, transaction) => {
+      if (transaction.local || !roles.following()) return
+      link.receive(Object.fromEntries([...event.keysChanged].map(key => [key, jsonClone(map.get(key))])))
+    }))
+  }
+
+  return {
+    transport: {
+      connect(name, receive, state) {
+        const link: Link = { receive, state }
+        links.set(name, link)
+        attach(name, link)
+        const current = channel(doc(), name).toJSON()
+        if (roles.following() && Object.keys(current).length > 0) receive(current)
+        return (next, fromRemote) => {
+          link.state = next
+          if (!fromRemote && roles.publishing()) writeChannel(doc(), name, next)
+        }
+      },
+    },
+    rebind() {
+      detach.forEach(stop => stop())
+      detach = []
+      for (const [name, link] of links) attach(name, link)
+    },
+    deliver() {
+      if (!roles.following()) return
+      for (const [name, link] of links) {
+        const state = channel(doc(), name).toJSON()
+        if (Object.keys(state).length > 0) link.receive(state)
+      }
+    },
+    publishAll() {
+      for (const [name, link] of links) writeChannel(doc(), name, link.state)
+    },
+  }
+}

package/src/client/tab-mirror.ts

@@ -0,0 +1,41 @@
+import type { Membership } from './membership-storage.ts'
+
+type TabMessage =
+  | { type: 'who' }
+  | { type: 'presenter', membership: Membership }
+  | { type: 'left', room: string }
+
+export interface TabHandlers {
+  /** Another tab asks which tab of this browser presents. */
+  asked(): void
+  /** A tab of this browser presents with `membership`. */
+  presenting(membership: Membership): void
+  /** The tab that presented `room` left it. */
+  left(room: string): void
+}
+
+/** The other tabs of this browser on the same deck: a presenter's other tabs watch the classroom as it does. */
+export interface TabMirror {
+  ask(): void
+  announce(membership: Membership): void
+  leave(room: string): void
+  close(): void
+}
+
+export function connectTabs(name: string, handlers: TabHandlers): TabMirror {
+  const tabs = typeof BroadcastChannel === 'undefined' ? undefined : new BroadcastChannel(name)
+  const tell = (message: TabMessage) => tabs?.postMessage(message)
+  if (tabs) {
+    tabs.onmessage = ({ data }: MessageEvent<TabMessage>) => {
+      if (data.type === 'who') handlers.asked()
+      else if (data.type === 'presenter') handlers.presenting(data.membership)
+      else if (data.type === 'left') handlers.left(data.room)
+    }
+  }
+  return {
+    ask: () => tell({ type: 'who' }),
+    announce: membership => tell({ type: 'presenter', membership }),
+    leave: room => tell({ type: 'left', room }),
+    close: () => tabs?.close(),
+  }
+}

package/src/client/viewer.ts

@@ -0,0 +1,6 @@
+import type { ViewerPluginContext } from '@lincyaw/viewer'
+import SessionBadge from './SessionBadge.tsx'
+
+export default function sessionViewerPlugin({ registerLayer }: ViewerPluginContext): void {
+  registerLayer({ id: 'presmium.session.badge', component: SessionBadge, scope: 'viewport' })
+}

package/src/client/ydoc.ts

@@ -0,0 +1,52 @@
+import type { Participant } from '@lincyaw/kernel'
+import type * as Y from 'yjs'
+import { changedEntries, clonePosition, endRecord, samePosition, startRecord } from '../domain/index.ts'
+import type { Position, SessionRecord } from '../domain/index.ts'
+
+const SESSION = 'session'
+
+export function observe(map: Y.Map<unknown>, handler: (event: Y.YMapEvent<unknown>, transaction: Y.Transaction) => void): () => void {
+  map.observe(handler)
+  return () => map.unobserve(handler)
+}
+
+export function sessionMap(doc: Y.Doc): Y.Map<unknown> {
+  return doc.getMap(SESSION)
+}
+
+export function sessionRecordOf(doc: Y.Doc): SessionRecord {
+  return sessionMap(doc).toJSON() as SessionRecord
+}
+
+function write(doc: Y.Doc, map: Y.Map<unknown>, entries: Iterable<[string, unknown]>): void {
+  doc.transact(() => {
+    for (const [key, value] of entries) map.set(key, value)
+  })
+}
+
+export function writeSessionStart(doc: Y.Doc, presenter: Participant, now: number): void {
+  write(doc, sessionMap(doc), Object.entries(startRecord(presenter, now)))
+}
+
+export function writeSessionEnd(doc: Y.Doc, now: number): void {
+  write(doc, sessionMap(doc), Object.entries(endRecord(now)))
+}
+
+export function publishCursor(doc: Y.Doc, position: Position): void {
+  const session = sessionMap(doc)
+  const cursor = clonePosition(position)
+  if (!samePosition(session.get('cursor') as Position | undefined, cursor)) session.set('cursor', cursor)
+}
+
+export function collection(doc: Y.Doc, name: string): Y.Map<unknown> {
+  return doc.getMap(`store:${name}`)
+}
+
+export function channel(doc: Y.Doc, name: string): Y.Map<unknown> {
+  return doc.getMap(`sync:${name}`)
+}
+
+export function writeChannel(doc: Y.Doc, name: string, state: Readonly<Record<string, unknown>>): void {
+  const map = channel(doc, name)
+  write(doc, map, changedEntries(key => map.get(key), state))
+}

package/src/client/yjs-store.ts

@@ -0,0 +1,47 @@
+import type { ClassroomStore } from '@lincyaw/kernel'
+import type * as Y from 'yjs'
+import { jsonClone } from '../domain/index.ts'
+import { collection, observe } from './ydoc.ts'
+
+export interface YjsStore {
+  store: ClassroomStore
+  /** Observes the collections of the current document and tells every listener. */
+  rebind(): void
+}
+
+export function createYjsStore(doc: () => Y.Doc, checkWrite: () => void): YjsStore {
+  const listeners = new Map<string, Set<() => void>>()
+  let detach: (() => void)[] = []
+  const attach = (name: string) => detach.push(observe(collection(doc(), name), () => listeners.get(name)?.forEach(listener => listener())))
+  return {
+    store: {
+      list: <T>(name: string) => [...collection(doc(), name).entries()].map(([id, value]) => ({ id, value: value as T })),
+      get: <T>(name: string, id: string) => collection(doc(), name).get(id) as T | undefined,
+      put(name, id, value) {
+        checkWrite()
+        collection(doc(), name).set(id, jsonClone(value))
+      },
+      remove(name, id) {
+        checkWrite()
+        collection(doc(), name).delete(id)
+      },
+      subscribe(name, listener) {
+        let set = listeners.get(name)
+        if (!set) {
+          listeners.set(name, set = new Set())
+          attach(name)
+        }
+        set.add(listener)
+        return () => {
+          set.delete(listener)
+        }
+      },
+    },
+    rebind() {
+      detach.forEach(stop => stop())
+      detach = []
+      for (const name of listeners.keys()) attach(name)
+      listeners.forEach(set => set.forEach(listener => listener()))
+    },
+  }
+}

package/src/domain/config.ts

@@ -0,0 +1,38 @@
+export const SESSION_ID = 'presmium.session'
+
+export const SYNC_PATH = 'sync'
+
+export interface LocalClassroom {
+  path: string
+  document: string
+}
+
+export function localServer(answer: LocalClassroom, page: { protocol: string, host: string }): { server: string, params: Record<string, string> } {
+  return { server: `${page.protocol === 'https:' ? 'wss:' : 'ws:'}//${page.host}${answer.path}`, params: { document: answer.document } }
+}
+
+export interface SessionConfig {
+  server?: string
+}
+
+export function toSessionConfig(config: Record<string, unknown>): SessionConfig {
+  const server = typeof config.server === 'string' ? config.server.trim() : ''
+  if (!server) return {}
+  return { server: server.replace(/^http(s?):\/\//, 'ws$1://').replace(/\/+$/, '') }
+}
+
+export function isLoopback(hostname: string): boolean {
+  return /^(?:localhost|127(?:\.\d{1,3}){3}|\[?::1\]?)$/i.test(hostname)
+}
+
+export function reachableServer(server: string, pageHostname: string): string {
+  let url: URL
+  try {
+    url = new URL(server)
+  } catch {
+    return server
+  }
+  if (!pageHostname || !isLoopback(url.hostname) || isLoopback(pageHostname)) return server
+  url.hostname = pageHostname
+  return url.href.replace(/\/+$/, '')
+}

package/src/domain/index.ts

@@ -0,0 +1,20 @@
+export { isLoopback, localServer, reachableServer, SESSION_ID, SYNC_PATH, toSessionConfig } from './config.ts'
+export type { LocalClassroom, SessionConfig } from './config.ts'
+export { archiveUrl, isLoopbackLink, joinRequest, joinUrl, readableString } from './links.ts'
+export type { JoinRequest } from './links.ts'
+export { MESSAGES } from './messages.ts'
+export type { SessionMessages } from './messages.ts'
+export {
+  changedEntries,
+  clonePosition,
+  endRecord,
+  followTarget,
+  jsonClone,
+  participantsOf,
+  samePosition,
+  sessionStatus,
+  startRecord,
+} from './session-record.ts'
+export type { FollowMode, Position, SessionRecord } from './session-record.ts'
+export { isClassroomSession, shortStatus, statusText } from './session-service.ts'
+export type { ClassroomSession, ClassroomSnapshot } from './session-service.ts'

package/src/domain/links.ts

@@ -0,0 +1,41 @@
+import { isLoopback } from './config.ts'
+
+const ROOM = /^[\w.-]{1,128}$/
+const ALPHABET = 'abcdefghjkmnpqrstuvwxyz23456789'
+
+export interface JoinRequest {
+  room: string
+  name?: string
+}
+
+export function joinRequest(search: string): JoinRequest | undefined {
+  const params = new URLSearchParams(search)
+  const room = params.get('room')?.trim()
+  if (!room || !ROOM.test(room)) return undefined
+  const name = params.get('name')?.trim()
+  return name ? { room, name } : { room }
+}
+
+export function joinUrl(base: string, room: string): string {
+  const url = new URL(base)
+  url.search = `?room=${encodeURIComponent(room)}`
+  url.hash = ''
+  return url.href
+}
+
+export function isLoopbackLink(link: string): boolean {
+  try {
+    return isLoopback(new URL(link).hostname)
+  } catch {
+    return false
+  }
+}
+
+export function readableString(random: Uint8Array): string {
+  return [...random].map(byte => ALPHABET[byte % ALPHABET.length]).join('')
+}
+
+export function archiveUrl(server: string, room: string, params: Record<string, string> = {}): string {
+  const query = new URLSearchParams(params).toString()
+  return `${server.replace(/^ws(s?):/, 'http$1:')}/archive/${encodeURIComponent(room)}${query ? `?${query}` : ''}`
+}

package/src/domain/messages.ts

@@ -0,0 +1,137 @@
+import type { Locale } from '@lincyaw/kernel'
+
+const zh = {
+  classroom: '课堂',
+  status: {
+    noServer: '未连接：文稿没有配置课堂服务',
+    failed: (error: string) => `未连接：${error}`,
+    invited: (room: string) => `未连接：受邀加入课堂 ${room}`,
+    idle: '未连接：尚未加入课堂',
+    archived: (file: string) => `课堂已结束并归档到 ${file}`,
+    ended: '课堂已结束',
+    connecting: '正在连接课堂服务…',
+    presenting: '课堂进行中，你是主讲',
+    following: '课堂进行中，正在跟随主讲',
+    browsing: '课堂进行中，自主浏览',
+  },
+  short: {
+    noServer: '未连接',
+    idle: '未加入',
+    archived: '已归档',
+    ended: '已结束',
+    connecting: '正在连接…',
+    presenter: '主讲',
+    follow: '跟随',
+    free: '自主',
+  },
+  hint: { beforeCommand: '文稿照常放映与阅读。要开课，启动 ', beforeKey: '，并在文稿 frontmatter 中设置 ', end: '。' },
+  nickname: '昵称',
+  create: '创建课堂',
+  join: '加入课堂',
+  joinRoom: (room: string) => `加入课堂 ${room}`,
+  role: { presenter: '（主讲）', learner: '（学习者）' },
+  joinLink: '加入链接：',
+  qr: '加入课堂的二维码',
+  participants: '参与者',
+  participantCount: (n: number) => `参与者（${n}）`,
+  end: '结束课堂',
+  archive: '归档课堂',
+  archiveTitle: '把课堂记录写入文稿目录，并从课堂服务中释放',
+  leaveClassroom: '离开课堂',
+  leave: '离开',
+  close: '关闭',
+  badge: '课堂状态',
+  followingPresenter: '正在跟随主讲',
+  browseAlone: '自主浏览',
+  browsingAlone: '自主浏览中',
+  presenterAt: (slide: number, step: number) => `主讲在第 ${slide} 页第 ${step} 步`,
+  backToPresenter: '回到主讲进度',
+  rejoin: (room: string) => `以主讲身份回到课堂 ${room}`,
+  rejoinTitle: '这个浏览器创建过这个课堂，可以继续主讲、结束与归档它',
+  loopbackLink: '学习者的设备打不开这个地址，请用局域网地址打开文稿',
+  refused: '课堂服务拒绝了你刚才的写入（例如超出长度的提问），页面已按课堂的记录重新同步',
+  defaultName: { presenter: '主讲', learner: '学习者' },
+  errors: {
+    noServer: '文稿没有配置课堂服务',
+    ended: '课堂已结束，不再接受写入',
+    archived: '课堂已归档',
+    closed: (code: number) => `课堂服务关闭了连接（${code}）`,
+    unreachable: (server: string) => `无法连接课堂服务 ${server}`,
+    onlyPresenterEnds: '只有主讲可以结束课堂',
+    onlyPresenterArchives: '只有主讲可以归档课堂',
+    notCreator: '只有创建课堂的主讲可以归档',
+    noRoom: '课堂服务中没有这个课堂',
+    alreadyArchived: '课堂已经归档',
+    archiveFailed: (status: number) => `无法归档课堂（${status}）`,
+  },
+}
+
+export type SessionMessages = typeof zh
+
+const en: SessionMessages = {
+  classroom: 'Classroom',
+  status: {
+    noServer: 'Not connected: the document has no classroom server',
+    failed: error => `Not connected: ${error}`,
+    invited: room => `Not connected: invited to classroom ${room}`,
+    idle: 'Not connected: not in a classroom',
+    archived: file => `The classroom has ended and is archived to ${file}`,
+    ended: 'The classroom has ended',
+    connecting: 'Connecting to the classroom server…',
+    presenting: 'Classroom in progress; you are presenting',
+    following: 'Classroom in progress; following the presenter',
+    browsing: 'Classroom in progress; browsing alone',
+  },
+  short: {
+    noServer: 'Not connected',
+    idle: 'Not joined',
+    archived: 'Archived',
+    ended: 'Ended',
+    connecting: 'Connecting…',
+    presenter: 'Presenting',
+    follow: 'Following',
+    free: 'Browsing',
+  },
+  hint: { beforeCommand: 'The document presents and reads as usual. To hold a classroom, start ', beforeKey: ' and set ', end: ' in the document frontmatter.' },
+  nickname: 'Nickname',
+  create: 'Create Classroom',
+  join: 'Join Classroom',
+  joinRoom: room => `Join Classroom ${room}`,
+  role: { presenter: ' (presenter)', learner: ' (learner)' },
+  joinLink: 'Join link: ',
+  qr: 'QR code to join the classroom',
+  participants: 'Participants',
+  participantCount: n => `Participants (${n})`,
+  end: 'End Classroom',
+  archive: 'Archive Classroom',
+  archiveTitle: 'Write the classroom record to the document folder and free it on the classroom server',
+  leaveClassroom: 'Leave Classroom',
+  leave: 'Leave',
+  close: 'Close',
+  badge: 'Classroom status',
+  followingPresenter: 'Following the presenter',
+  browseAlone: 'Browse Alone',
+  browsingAlone: 'Browsing alone',
+  presenterAt: (slide, step) => `The presenter is at page ${slide}, step ${step}`,
+  backToPresenter: 'Back to Presenter',
+  rejoin: room => `Rejoin Classroom ${room} as Presenter`,
+  rejoinTitle: 'This browser created the classroom: go on presenting it, end it, and archive it',
+  loopbackLink: 'Learners’ devices can’t open this address; open the document at its address on the local network',
+  refused: 'The classroom server refused your last write (such as a question over the length limit); the page has synced again with the classroom',
+  defaultName: { presenter: 'Presenter', learner: 'Learner' },
+  errors: {
+    noServer: 'The document has no classroom server',
+    ended: 'The classroom has ended and takes no more writes',
+    archived: 'The classroom has been archived',
+    closed: code => `The classroom server closed the connection (${code})`,
+    unreachable: server => `Couldn’t reach the classroom server ${server}`,
+    onlyPresenterEnds: 'Only the presenter can end the classroom',
+    onlyPresenterArchives: 'Only the presenter can archive the classroom',
+    notCreator: 'Only the presenter who created the classroom can archive it',
+    noRoom: 'The classroom server has no such classroom',
+    alreadyArchived: 'The classroom is already archived',
+    archiveFailed: status => `Couldn’t archive the classroom (${status})`,
+  },
+}
+
+export const MESSAGES: Record<Locale, SessionMessages> = { 'zh-CN': zh, en }