@cmodjs/core 0.2.3 → 1.0.0

package/src/testing/fake-sessions.ts

@@ -0,0 +1,203 @@
+import { isObject } from '../records.js'
+import { Document } from '../session/context/turn/message/document.js'
+import { Message, searchText, skillPrefix, type Row } from '../session/context/turn/message/message.js'
+import { Note } from '../session/context/turn/message/note.js'
+import { Notice } from '../session/context/turn/message/notice.js'
+import { Prompt } from '../session/context/turn/message/prompt.js'
+import { Reply } from '../session/context/turn/message/reply.js'
+import { Mod, Person, Schedule, type Sender } from '../session/context/turn/message/sender.js'
+import { Task } from '../session/goal/task.js'
+import { Skill } from '../session/context/turn/message/skill.js'
+import { ToolCall } from '../session/context/turn/message/tool-call.js'
+import { ToolResult } from '../session/context/turn/message/tool-result.js'
+import { createConversation, emptyConversation, searchLimit, type ContextData, type Conversation, type SessionChange, type SessionData, type TaskData, type TurnData } from '../session/conversation.js'
+import { conversationMethods, isHeardBy, type Subscription } from '../runtime/sessions.js'
+import { receivedMatcher } from '../utils/matcher.js'
+import { firstLine, messageOf } from '../utils/text.js'
+
+export type MessageDraft =
+  | { readonly type: typeof Prompt; readonly text: string; readonly from?: Sender }
+  | { readonly type: typeof Note; readonly text: string; readonly from?: Sender }
+  | { readonly type: typeof Reply; readonly text: string }
+  | { readonly type: typeof ToolCall; readonly name: string; readonly input?: Readonly<Record<string, unknown>>; readonly callId?: string }
+  | { readonly type: typeof ToolResult; readonly callId: string; readonly text: string; readonly isError?: boolean }
+  | { readonly type: typeof Skill; readonly name: string; readonly text: string }
+  | { readonly type: typeof Document; readonly path: string; readonly text: string }
+  | { readonly type: typeof Notice; readonly text: string }
+
+export type FakeSession = Partial<Omit<SessionData, 'id'>> & {
+  readonly id: string
+  readonly messages?: readonly MessageDraft[]
+  readonly goal?: string
+}
+
+type Kept = {
+  data: SessionData
+  readonly conversation: Conversation
+  readonly messages: Message[]
+  readonly turns: Map<string, TurnData>
+  readonly contexts: Map<number, ContextData>
+  readonly tasks: Map<string, TaskData>
+}
+
+type Heard = { readonly event: Subscription['event']; readonly matcher: unknown }
+
+
+export type FakeSessions = {
+  answer(caller: string, method: string, input: unknown): unknown
+  add(draft: MessageDraft, task?: string): Message[]
+  endTurn(): void
+  compact(): void
+  startTask(task: { readonly title: string; readonly agentType?: string; readonly model?: string; readonly openedBy?: string }): string
+  start(id: string): void
+  readonly sent: { readonly session: string; readonly type: string; readonly text: string; readonly as?: string }[]
+}
+
+export function fakeSessions({ project, given, push }: { readonly project: () => string; readonly given: readonly FakeSession[]; readonly push: (mod: string, session: string, change: SessionChange) => void }): FakeSessions {
+  const kept = new Map<string, Kept>()
+  const heard = new Map<string, Map<string, readonly Heard[]>>()
+  const sent: FakeSessions['sent'] = []
+  let current = ''
+  let clock = Date.parse('2026-01-01T00:00:00.000Z')
+  let ids = 0
+  const now = () => new Date((clock += 1000)).toISOString()
+
+  const keep = (data: SessionData): Kept => {
+    const session: Kept = { data, conversation: createConversation(emptyConversation(data.id)), messages: [], turns: new Map(), contexts: new Map(), tasks: new Map() }
+    kept.set(data.id, session)
+    return session
+  }
+
+  const record = (session: Kept, changes: readonly SessionChange[]) => {
+    for (const change of changes) {
+      if (change.type === Message) session.messages.push(change.message)
+      if ('turn' in change) session.turns.set(change.turn.prompt.id, change.turn)
+      if ('context' in change) session.contexts.set(change.context.number, change.context)
+      if ('task' in change) session.tasks.set(change.task.id, change.task)
+      session.data = { ...session.data, lastAt: change.type === Message ? change.message.at : session.data.lastAt, ...(session.data.title === '' && change.type === Message && change.message.type === Prompt && change.message.from.type === Person ? { title: firstLine(change.message.text) } : {}) }
+      for (const [mod, sessions] of heard) {
+        if ((sessions.get(session.data.id) ?? []).some(({ event, matcher }) => isHeardBy(event, matcher, change))) push(mod, session.data.id, change)
+      }
+    }
+  }
+
+  const add = (session: Kept, draft: MessageDraft, task?: string) => {
+    const before = session.messages.length
+    record(session, session.conversation.add(rowOf(draft, `message-${(ids += 1)}`, now()), task))
+    return session.messages.slice(before)
+  }
+
+  for (const each of given) {
+    const session = keep({ title: '', project: project(), cwd: project(), model: 'test-model', startedAt: now(), lastAt: '', isRunning: false, ...each })
+    for (const draft of each.messages ?? []) add(session, draft)
+    if (each.goal !== undefined) record(session, session.conversation.changeGoal(each.goal))
+  }
+
+  const sessionOf = (id: string) => {
+    const session = kept.get(id)
+    if (session === undefined) throw new Error(`No Claude Code transcript is named ${id}.jsonl. Give it to testMod as { sessions: [{ id: '${id}' }] }.`)
+    return session
+  }
+
+  const currentSession = () => sessionOf(current)
+
+  const lastOf = <Item>(items: readonly Item[], last: unknown): Item[] => (typeof last === 'number' ? items.slice(-last) : [...items])
+
+  const isInScope = (session: Kept, request: Readonly<Record<string, unknown>>) =>
+    (request['everyProject'] === true || session.data.project === project()) && session.data.lastAt >= (typeof request['since'] === 'string' ? request['since'] : '') && (request['running'] !== true || session.data.isRunning)
+
+  const methods: Readonly<Record<string, (request: Readonly<Record<string, unknown>>, caller: string) => unknown>> = {
+    [conversationMethods.sessions]: (request) =>
+      [...kept.values()]
+        .filter((session) => isInScope(session, request))
+        .map((session) => session.data)
+        .toSorted((first, second) => second.lastAt.localeCompare(first.lastAt)),
+    [conversationMethods.search](request) {
+      const text = String(request['text'])
+      if ([...text].length < 3) throw new Error('cmod history search takes at least 3 characters.')
+      const found = [...kept.values()]
+        .filter((session) => isInScope(session, request))
+        .flatMap((session) => session.messages)
+        .filter((message) => searchText(message).toLowerCase().includes(text.toLowerCase()))
+        .toSorted((first, second) => second.at.localeCompare(first.at))
+      const before = isObject(request['before']) ? request['before'] : undefined
+      const start = before === undefined ? 0 : found.findIndex((message) => message.session === before['session'] && message.id === before['id']) + 1
+      return found.slice(start, start + (typeof request['limit'] === 'number' ? request['limit'] : searchLimit))
+    },
+    [conversationMethods.messages](request) {
+      const session = sessionOf(String(request['session']))
+      const fits = session.messages.filter((message) => message.task === request['task'] && (request['turn'] === undefined || message.turn === request['turn']))
+      const after = typeof request['after'] === 'string' ? fits.findIndex((message) => message.id === request['after']) + 1 : 0
+      return lastOf(fits.slice(after), request['last'])
+    },
+    [conversationMethods.turns]: (request) => lastOf([...sessionOf(String(request['session'])).turns.values()].filter((turn) => request['context'] === undefined || turn.context === request['context']), request['last']),
+    [conversationMethods.contexts]: (request) => [...sessionOf(String(request['session'])).contexts.values()],
+    [conversationMethods.tasks]: (request) => [...sessionOf(String(request['session'])).tasks.values()].filter((task) => task.parent === request['task']),
+    [conversationMethods.goal]: (request) => ({ text: sessionOf(String(request['session'])).conversation.state.goal ?? '' }),
+    [conversationMethods.updateGoal](request) {
+      const session = sessionOf(String(request['session']))
+      record(session, session.conversation.changeGoal(String(request['text'])))
+      return null
+    },
+    [conversationMethods.subscribe](request, caller) {
+      const list = Array.isArray(request['subscriptions']) ? (request['subscriptions'] as readonly Subscription[]) : []
+      const sessions = heard.get(caller) ?? new Map<string, readonly Heard[]>()
+      sessions.set(String(request['session']), list.map(({ event, matcher }) => ({ event, matcher: matcher === undefined ? undefined : receivedMatcher(matcher) })))
+      heard.set(caller, sessions)
+      return null
+    },
+    [conversationMethods.send](request) {
+      sent.push({ session: String(request['session']), type: String(request['type']), text: String(request['text']), ...(typeof request['as'] === 'string' ? { as: request['as'] } : {}) })
+      return null
+    },
+  }
+
+  return {
+    answer(caller, method, input) {
+      const run = methods[method]
+      if (run === undefined) return undefined
+      try {
+        return { value: run(isObject(input) ? input : {}, caller) }
+      } catch (error) {
+        return { deny: messageOf(error) }
+      }
+    },
+    add: (draft, task) => add(currentSession(), draft, task),
+    endTurn() {
+      const session = currentSession()
+      record(session, session.conversation.add({ id: `turn-end-${(ids += 1)}`, at: now(), type: 'system', name: 'turn_duration', isMeta: false, isSummary: false, content: [] }))
+    },
+    compact() {
+      const session = currentSession()
+      const at = now()
+      record(session, [...session.conversation.endContext(at), ...session.conversation.startContext(at)])
+    },
+    startTask({ title, agentType = 'general-purpose', model, openedBy = '' }) {
+      const session = currentSession()
+      const id = `task-${(ids += 1)}`
+      record(session, session.conversation.startTask({ id, title, agentType, openedBy, openedAt: now(), ...(model === undefined ? {} : { model }) }))
+      return id
+    },
+    start(id) {
+      current = id
+      const session = kept.get(id) ?? keep({ id, title: '', project: project(), cwd: project(), model: 'test-model', startedAt: now(), lastAt: now(), isRunning: true })
+      session.data = { ...session.data, isRunning: true }
+      if (session.conversation.state.context === 0) record(session, session.conversation.startContext(now()))
+    },
+    sent,
+  }
+}
+
+function rowOf(draft: MessageDraft, id: string, at: string): Row {
+  const base = { id, at, isMeta: false, isSummary: false }
+  const text = (value: string) => [{ type: 'text', text: value }]
+  const origin = (from: Sender | undefined) => (from === undefined || from.type === Person ? { kind: 'human' } : from.type === Mod ? { kind: 'plugin', name: from.name, ...(from.as === Person ? { asUser: true } : {}) } : from.type === 'session' ? { kind: 'peer' } : from.type === Task ? { kind: 'task-notification' } : { kind: from.type === Schedule ? 'scheduled-trigger' : from.type, ...(from.name === undefined ? {} : { server: from.name }) })
+  if (draft.type === Prompt) return { ...base, type: 'user', content: text(draft.text), origin: origin(draft.from) }
+  if (draft.type === Note) return { ...base, type: 'user', isMeta: true, content: text(draft.text), origin: origin(draft.from ?? { type: Mod, name: 'test' }) }
+  if (draft.type === Reply) return { ...base, type: 'assistant', content: text(draft.text) }
+  if (draft.type === ToolCall) return { ...base, type: 'assistant', content: [{ type: 'tool_use', id: draft.callId ?? `toolu_${id}`, name: draft.name, input: draft.input ?? {} }], cwd: '/test/project' }
+  if (draft.type === ToolResult) return { ...base, type: 'user', content: [{ type: 'tool_result', tool_use_id: draft.callId, content: draft.text, ...(draft.isError === true ? { is_error: true } : {}) }] }
+  if (draft.type === Skill) return { ...base, type: 'user', isMeta: true, content: text(`${skillPrefix} /skills/${draft.name}\n\n${draft.text}`) }
+  if (draft.type === Document) return { ...base, type: 'attachment', name: 'nested_memory', content: text(draft.text), path: draft.path }
+  return { ...base, type: 'system', name: 'informational', content: text(draft.text) }
+}

package/src/testing.ts

@@ -17,23 +17,35 @@ import type {
   UiPressArgument,
   UiSelectArgument,
 } from 'claude-code'
-import type { Reply } from './jobs/slash-command.js'
-import type { ModDefinition, ModEvent } from './mod.js'
+import type { CommandReply } from './jobs/slash-command.js'
+import type { Hook, ModDefinition } from './mod.js'
 import type { Options, OptionValues } from './options.js'
 import { readSteps, storeFolder, type Steps } from './records.js'
 import type { Claude } from './runtime/claude.js'
-import { answerCall, notInstalled } from './runtime/dependencies.js'
+import { answerCall, cmodPluginName, notInstalled } from './runtime/dependencies.js'
 import type { RoutedEvent } from './runtime/hooks.js'
 import { toolInputOf } from './runtime/tool-calls.js'
 import { createLifecycle } from './runtime/lifecycle.js'
 import { MissingOptions } from './runtime/options.js'
-import { fakeClaude, type Fakes, type Shown, type TestCall } from './testing/fake-claude.js'
+import { conversationMethods } from './runtime/sessions.js'
+import type { ShownToast } from './runtime/toaster.js'
+import type { Message } from './session/context/turn/message/message.js'
+import { Note } from './session/context/turn/message/note.js'
+import { Prompt } from './session/context/turn/message/prompt.js'
+import { Mod, Person } from './session/context/turn/message/sender.js'
+import { calledAnswer, fakeClaude, type Fakes, type Shown as ShownByClaude, type TestCall } from './testing/fake-claude.js'
 import { elements, findElement, rowsOf } from './testing/fake-elements.js'
 import { fakeFiles } from './testing/fake-files.js'
+import { fakeSessions, type FakeSession, type FakeSessions, type MessageDraft } from './testing/fake-sessions.js'
 import { listed } from './utils/text.js'
-import type { Slot, SlotProps } from './ui/slots.js'
+import { componentOf, type ComponentPlace, type PlaceProps } from './ui/places.js'
 
-export type { Fakes, Shown, TestCall } from './testing/fake-claude.js'
+export type { Fakes, TestCall } from './testing/fake-claude.js'
+export type { FakeSession, MessageDraft } from './testing/fake-sessions.js'
+export type { RoutedEvent } from './runtime/hooks.js'
+export type { ShownToast } from './runtime/toaster.js'
+
+export type Shown = ShownByClaude & { readonly toasts: readonly ShownToast[]; readonly sent: FakeSessions['sent'] }
 
 export type TestOptions<State extends object, Declared extends Options = Options> = {
   readonly state?: { readonly [Lifetime in keyof State]?: Partial<State[Lifetime]> }
@@ -45,23 +57,28 @@ export type TestOptions<State extends object, Declared extends Options = Options
   readonly dependencies?: { readonly [Name in keyof CmodDependencies]?: CmodDependencies[Name] }
   readonly files?: Readonly<Record<string, string>>
   readonly links?: Readonly<Record<string, string>>
+  readonly sessions?: readonly FakeSession[]
 }
 
 type FilledField = 'session_id' | 'transcript_path' | 'cwd' | 'hook_event_name' | 'tool_use_id'
 
-export type TestInput<E extends ModEvent> = Omit<ClassicHookInputs[E], FilledField> & Partial<Pick<ClassicHookInputs[E], FilledField & keyof ClassicHookInputs[E]>>
+export type TestInput<H extends Hook> = Omit<ClassicHookInputs[H], FilledField> & Partial<Pick<ClassicHookInputs[H], FilledField & keyof ClassicHookInputs[H]>>
 
 export type TestedMod<State extends object> = {
   start(): Promise<void>
-  fire<E extends ModEvent>(event: E, input: TestInput<E>, below?: EventResult<`classic.${E}`>): Promise<EventResult<`classic.${E}`>>
+  fire<H extends Hook>(hook: H, input: TestInput<H>, below?: EventResult<`classic.${H}`>): Promise<EventResult<`classic.${H}`>>
   fire<N extends RoutedEvent>(event: N, input: Args<N>, below?: EventResult<N>): Promise<EventResult<N>>
   settle(): Promise<void>
+  add(message: MessageDraft, options?: { readonly task?: string }): Promise<Message[]>
+  endTurn(): Promise<void>
+  compact(): Promise<void>
+  startTask(task: { readonly title: string; readonly agentType?: string; readonly model?: string; readonly openedBy?: string }): Promise<string>
   lines(paneId: string): Promise<string[]>
-  lines<S extends Slot<object, object, { readonly component: RenderComponent }>>(slot: S, props: Omit<SlotProps<S>, 'Default'>, requestId?: string): Promise<string[]>
-  type(line: string): Promise<Reply>
+  lines<P extends ComponentPlace>(place: P, props: Omit<PlaceProps<P>, 'Default'>, requestId?: string): Promise<string[]>
+  type(line: string): Promise<CommandReply>
   callTool(name: string, input: Record<string, unknown>): Promise<EventResult<'tool.call'>>
   press(paneId: string, key: string, link?: string): Promise<void>
-  input(paneId: string, key: string, text: string, kind?: UiInputArgument['kind']): Promise<void>
+  input(paneId: string, key: string, text: string, type?: UiInputArgument['kind']): Promise<void>
   select(paneId: string, key: string, value: string): Promise<void>
   moveTo(projectRoot: string, cwd?: string): Promise<void>
   readonly state: Readonly<State>
@@ -76,7 +93,7 @@ const defaultRows = 24
 
 const presentation: CommandPresentation = { isFullscreen: false, columns: defaultColumns }
 
-const toolUseEvents: readonly string[] = ['PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'] satisfies readonly ModEvent[]
+const toolUseEvents: readonly string[] = ['PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'PermissionDenied'] satisfies readonly Hook[]
 
 export function testMod<State extends object, Declared extends Options = Options>(definition: ModDefinition<State, string, Declared>, options: TestOptions<State, Declared> = {}): TestedMod<State> {
   installJsx()
@@ -93,14 +110,37 @@ export function testMod<State extends object, Declared extends Options = Options
   fake.claude.session.id = async () => sessionId
   fake.claude.session.root = async () => projectRoot
   fake.claude.session.cwd = async () => cwd
-  fake.fakes.cmod.call = fakeDependencies(options.dependencies ?? {})
+  const conversations = fakeSessions({
+    project: () => projectRoot,
+    given: options.sessions ?? [],
+    push: (mod, session, change) => {
+      if (mod !== name) return
+      const pushed = { to: mod, method: conversationMethods.changed, input: { session, change }, caller: cmodPluginName } as unknown as Frozen<Args<'cmod.call'>>
+      void lifecycle.route('cmod.call', pushed, async () => ({ deny: notInstalled(mod) }))
+    },
+  })
+  conversations.start(sessionId)
+  fake.fakes.cmod.call = fakeDependencies(name, options.dependencies ?? {}, conversations)
+  const appendRow = fake.claude.session.append
+  fake.claude.session.append = async (args) => {
+    const added = await appendRow(args)
+    if (added.deny === undefined) conversations.add({ type: Note, text: args.message.content.map((block) => (typeof block['text'] === 'string' ? block['text'] : '')).join(''), from: { type: Mod, name } })
+    return added
+  }
+  const submitRow = fake.claude.prompt.submit
+  fake.claude.prompt.submit = async (args) => {
+    const submitted = await submitRow(args)
+    conversations.add({ type: Prompt, text: args.text, from: { type: Mod, name, ...(args.asUser === true ? { as: Person } : {}) } })
+    return submitted
+  }
   const firedAgents = new Map<string, string>()
   const listAgents = fake.claude.agent.list
   fake.claude.agent.list = async () => {
     if (fake.fakes.agent.list !== undefined || firedAgents.size === 0) return listAgents()
     return [...firedAgents].map(([id, type]) => ({ id, type, description: '', status: 'running' as const }))
   }
-  Object.assign(fake.fakes.fs, fakeFiles(options.files ?? {}, options.links))
+  const files = fakeFiles(options.files ?? {}, options.links)
+  Object.assign(fake.fakes.fs, files)
   const starting = options.state as Record<string, object> | undefined
   const declared = Object.entries(definition.state ?? {}) as [string, object][]
   const state = Object.fromEntries(declared.map(([lifetime, values]) => [lifetime, { ...values, ...starting?.[lifetime] }])) as State
@@ -122,6 +162,7 @@ export function testMod<State extends object, Declared extends Options = Options
       }
     })
     await started
+    await fake.settle()
     const { failure } = lifecycle
     if (failure instanceof MissingOptions) {
       const given = failure.keys.map((key) => `${key}: …`).join(', ')
@@ -166,14 +207,19 @@ export function testMod<State extends object, Declared extends Options = Options
 
   const fire = ((event: string, input: object, below?: unknown) => {
     if (event.includes('.')) return route(event as RoutedEvent, input, below)
-    if (event === 'SessionStart') sessionId = (input as { session_id?: string }).session_id ?? sessionId
+    if (event === 'SessionStart') {
+      sessionId = (input as { session_id?: string }).session_id ?? sessionId
+      conversations.start(sessionId)
+    }
     if (event === 'UserPromptSubmit') {
       cwd = cwdAfterPrompt ?? cwd
       cwdAfterPrompt = undefined
     }
     const toolUse = toolUseEvents.includes(event) ? { tool_use_id: `toolu_${(toolUses += 1)}` } : {}
-    const filled = { session_id: sessionId, transcript_path: '/test/transcript.jsonl', cwd, hook_event_name: event, ...toolUse, ...input }
-    if (event !== 'PreToolUse') return route(`classic.${event as Exclude<ModEvent, 'PreToolUse'>}`, filled, below)
+    const transcript = `/test/transcripts/${sessionId}.jsonl`
+    const filled = { session_id: sessionId, transcript_path: transcript, cwd, hook_event_name: event, ...toolUse, ...input }
+    if (event === 'SessionStart' && !('transcript_path' in input)) return files.write(transcript, '').then(() => route('classic.SessionStart', filled, below))
+    if (event !== 'PreToolUse') return route(`classic.${event as Exclude<Hook, 'PreToolUse'>}`, filled, below)
     return firePreToolUse(filled as ClassicHookInputs['PreToolUse'], below as { deny?: string } | undefined)
   }) as TestedMod<State>['fire']
 
@@ -187,7 +233,7 @@ export function testMod<State extends object, Declared extends Options = Options
     const answer = await lifecycle.route('tool.call', envelope, async (e) => {
       reached = e
       check = await lifecycle.route('tool.check', { tool: e.tool, input: toolInputOf(e), tool_use_id: e.tool_use_id, ...(e.agentId === undefined ? {} : { agentId: e.agentId }) }, async () => asks)
-      return (check.decision === 'deny' ? { deny: check.reason ?? '' } : { result: '' }) as EventResult<'tool.call'>
+      return check.decision === 'deny' ? { deny: check.reason ?? '' } : { result: '' }
     })
     const updatedInput = toolInputOf(reached)
     const decided = check === asks ? {} : check.decision === 'allow' ? { allow: true } : check.decision === 'ask' ? { ask: check.reason ?? '' } : {}
@@ -198,14 +244,37 @@ export function testMod<State extends object, Declared extends Options = Options
     } as EventResult<'classic.PreToolUse'>
   }
 
+  const settled = async <Value>(value: Value) => {
+    await fake.settle()
+    return value
+  }
+
   return {
     start,
     fire,
     settle: fake.settle,
-    lines: (async (target: string | { readonly component: RenderComponent }, props: object = {}, requestId?: string) => {
-      const { drawing, columns } = typeof target === 'string' ? await drawPane(target) : await drawSlot(target.component, props, requestId)
+    add: async (message, added) => {
+      await start()
+      return settled(conversations.add(message, added?.task))
+    },
+    endTurn: async () => {
+      await start()
+      await settled(conversations.endTurn())
+    },
+    compact: async () => {
+      await start()
+      await settled(conversations.compact())
+    },
+    startTask: async (task) => {
+      await start()
+      return settled(conversations.startTask(task))
+    },
+    lines: async (target: string, props?: object, requestId?: string) => {
+      const component = componentOf(target as ComponentPlace)
+      if (props !== undefined && component === undefined) throw new Error(`lines takes a pane id, or a place render draws and its props, and ${target} is neither a place such as ToolCall nor called without props.`)
+      const { drawing, columns } = props === undefined || component === undefined ? await drawPane(target) : await drawSlot(component, props, requestId)
       return rowsOf(drawing, columns).map((row) => row.trimEnd())
-    }) as TestedMod<State>['lines'],
+    },
     async type(line) {
       const typed = /^\/(\S+)\s*(.*)$/s.exec(line)
       if (typed === null) throw new Error(`type takes a slash command the way the user types it, such as tested.type('/help'), and "${line}" does not start with /.`)
@@ -230,16 +299,16 @@ export function testMod<State extends object, Declared extends Options = Options
       const props = await drawnElement(paneId, link === undefined ? 'Button' : 'Markdown', key)
       if (link !== undefined && props['onLinkPress'] === undefined) throw new Error(`The Markdown "${key}" in the pane "${paneId}" of ${name} has no onLinkPress, so Claude Code opens its links itself.`)
       const pressed: UiPressArgument = { ...eventIn(paneId, String(props['key'])), ...(link === undefined ? {} : { link: { href: link } }) }
-      await lifecycle.route('ui.press', pressed as Frozen<Args<'ui.press'>>, async (e) => {
+      await lifecycle.route('ui.press', pressed, async (e) => {
         if (e.link === undefined) await (props['onPress'] as (e: UiPressArgument) => unknown)(e)
         else await (props['onLinkPress'] as (link: PressedLink, e: UiPressArgument) => unknown)(e.link, e)
         return { element: e.element }
       })
     },
-    async input(paneId, key, text, kind = 'submit') {
+    async input(paneId, key, text, type = 'submit') {
       const props = await drawnElement(paneId, 'Input', key)
-      const typed: UiInputArgument = { ...eventIn(paneId, key), kind, value: text }
-      await (props[kind === 'submit' ? 'onSubmit' : 'onInput'] as ((value: string, e: UiInputArgument) => unknown) | undefined)?.(text, typed)
+      const typed: UiInputArgument = { ...eventIn(paneId, key), kind: type, value: text }
+      await (props[type === 'submit' ? 'onSubmit' : 'onInput'] as ((value: string, e: UiInputArgument) => unknown) | undefined)?.(text, typed)
     },
     async select(paneId, key, value) {
       const props = await drawnElement(paneId, 'Select', key)
@@ -269,17 +338,24 @@ export function testMod<State extends object, Declared extends Options = Options
     },
     calls: fake.calls,
     fakes: fake.fakes,
-    shown: fake.shown,
+    shown: {
+      ...fake.shown,
+      get toasts() {
+        return lifecycle.toasts
+      },
+      sent: conversations.sent,
+    },
   }
 }
 
-function fakeDependencies(dependencies: NonNullable<TestOptions<object>['dependencies']>): Claude['cmod']['call'] {
-  const apis = dependencies as Readonly<Record<string, Parameters<typeof answerCall>[1] | undefined>>
+function fakeDependencies(caller: string, dependencies: NonNullable<TestOptions<object>['dependencies']>, conversations: FakeSessions): Claude['cmod']['call'] {
+  const cmod = { forkParent: () => null, updateSettings: () => null }
+  const apis = { [cmodPluginName]: cmod, ...dependencies } as Readonly<Record<string, Parameters<typeof answerCall>[1] | undefined>>
   return async (call) => {
+    const served = call.to === cmodPluginName ? conversations.answer(caller, call.method, call.input) : undefined
+    if (served !== undefined) return calledAnswer(caller, served as EventResult<'cmod.call'>)
     const api = apis[call.to]
-    const answer = api === undefined ? { deny: notInstalled(call.to) } : await answerCall(call.to, api, call)
-    if (answer.deny !== undefined) throw new Error(answer.deny)
-    return answer.value
+    return calledAnswer(caller, api === undefined ? { deny: notInstalled(call.to) } : await answerCall(call.to, api, call))
   }
 }
 
@@ -294,7 +370,7 @@ function plainOutput({ component, props }: Args<'ui.render'>): RenderElement {
   return elements.Box({ flexDirection: 'column', children: [elements.Text({ children: component }), elements.Box({ flexDirection: 'column', paddingLeft: 2, children: rows })] })
 }
 
-function replyOf({ text, context }: CommandRunResult): Reply {
+function replyOf({ text, context }: CommandRunResult): CommandReply {
   return { ...(text === undefined ? {} : { text }), ...(context === undefined ? {} : { context: context.join('\n') }) }
 }
 
@@ -302,7 +378,10 @@ async function modSteps(): Promise<Steps> {
   const manifest = '../../../package.json'
   const loaded: unknown = await import(manifest, { with: { type: 'json' } }).then(
     (module: { default: unknown }) => module.default,
-    () => undefined,
+    (error: { readonly code?: unknown }) => {
+      if (error.code === 'ERR_MODULE_NOT_FOUND') return undefined
+      throw error
+    },
   )
   return readSteps(loaded) ?? {}
 }

package/src/ui/components.ts

@@ -49,9 +49,9 @@ export function Pagination({ page, pages, onPage }: { readonly page: number; rea
   })
 }
 
-export function ProgressBar({ done, total, width = 24 }: { readonly done: number; readonly total: number; readonly width?: number }): RenderElement {
-  const filled = total > 0 ? Math.round(Math.min(done / total, 1) * width) : 0
-  return Text({ children: [Text({ color: 'claude', children: '█'.repeat(filled) }), Text({ color: 'subtle', children: '░'.repeat(width - filled) }), '  ', Text({ dimColor: true, children: `${done}/${total}` })] })
+export function Progress({ value, width = 24 }: { readonly value: number; readonly width?: number }): RenderElement {
+  const filled = Math.round((Math.min(Math.max(value, 0), 100) / 100) * width)
+  return Text({ children: [Text({ color: 'claude', children: '█'.repeat(filled) }), Text({ color: 'subtle', children: '░'.repeat(width - filled) })] })
 }
 
 const cardColumns = 36

package/src/ui/elements.ts

@@ -6,25 +6,39 @@ type CompletedTable = Record<ElementName, (props: object) => RenderElement>
 
 type Drawing = { readonly table: CompletedTable; readonly markdown: ((props: MarkdownProps) => RenderElement) | undefined }
 
+const unbuilt = Symbol('an element built outside a render')
+
+type Unbuilt = { readonly [unbuilt]: { readonly name: ElementName; readonly props: object } }
+
 let drawing: Drawing | undefined
 
 export function drawWith<Drawn>(table: ElementTable, draw: () => Drawn, markdown?: (props: MarkdownProps) => RenderElement): Drawn {
   const outer = drawing
-  drawing = { table: table as CompletedTable, markdown }
+  const current = { table: table as CompletedTable, markdown }
+  drawing = current
   try {
-    return draw()
+    return built(current, draw()) as Drawn
   } finally {
     drawing = outer
   }
 }
 
 function element<Name extends keyof Terminal & ElementName>(name: Name): Terminal[Name] {
-  const construct = (props: object) => {
-    if (drawing === undefined) throw new Error(`${name} was called outside a render. Use it inside a pane's render or a slot's component.`)
-    if (name === 'Markdown' && drawing.markdown !== undefined) return drawing.markdown(props as MarkdownProps)
-    return drawing.table[name](props)
-  }
-  return construct as Terminal[Name]
+  const construct = (props: object) => (drawing === undefined ? ({ [unbuilt]: { name, props } } satisfies Unbuilt as unknown as RenderElement) : build(drawing, name, props))
+  return construct
+}
+
+function build(current: Drawing, name: ElementName, props: object): RenderElement {
+  const ready = 'children' in props ? { ...props, children: built(current, props.children) } : props
+  if (name === 'Markdown' && current.markdown !== undefined) return current.markdown(ready as MarkdownProps)
+  return current.table[name](ready)
+}
+
+function built(current: Drawing, value: unknown): unknown {
+  if (Array.isArray(value)) return value.map((child: unknown) => built(current, child))
+  if (typeof value !== 'object' || value === null || !(unbuilt in value)) return value
+  const { name, props } = (value as Unbuilt)[unbuilt]
+  return build(current, name, props)
 }
 
 export const Box = element('Box')

package/src/ui/markdown.ts

@@ -1,11 +1,9 @@
 import type { Nodes, RootContent } from 'mdast'
 import { fromMarkdown, gfm, gfmFromMarkdown, toString } from '../vendor-markdown.js'
-import type { Slot, SlotProps } from './slots.js'
+import type { PlaceProps } from './places.js'
 
 type Block = { readonly text: string; readonly source: string }
 
-type MarkdownSlot<Props extends object = object> = Slot<Props, { readonly source?: string }, { readonly markdown: MarkdownKind }>
-
 type BlockFields = {
   heading: { readonly depth: 1 | 2 | 3 | 4 | 5 | 6 }
   code: { readonly lang: string | undefined; readonly meta: string | undefined; readonly value: string }
@@ -14,18 +12,31 @@ type BlockFields = {
   html: { readonly value: string }
 }
 
-type BlockProps<Type extends string> = Type extends keyof BlockFields ? Block & BlockFields[Type] : Block
+export type BlockProps<Type extends string> = Type extends keyof BlockFields ? Block & BlockFields[Type] : Block
 
 export type MarkdownPiece<Render> = { readonly text: string } | { readonly render: Render; readonly props: Block }
 
 export type MarkdownReader = <Render>(text: string, renderOf: (type: string) => Render | undefined, replyId?: string) => readonly MarkdownPiece<Render>[]
 
-export type MarkdownKind = {
+export type MarkdownPlace<Type extends string = string> = {
   readonly name: string
-  readonly type: string
-  readonly createReader: () => MarkdownReader
+  readonly markdown: Type
+  createReader(): MarkdownReader
 }
 
+function markdownPlace<const Type extends string>(name: string, markdown: Type): MarkdownPlace<Type> {
+  return { name, markdown, createReader }
+}
+
+export const Heading = markdownPlace('Heading', 'heading')
+export const Paragraph = markdownPlace('Paragraph', 'paragraph')
+export const CodeBlock = markdownPlace('CodeBlock', 'code')
+export const BlockQuote = markdownPlace('BlockQuote', 'blockquote')
+export const List = markdownPlace('List', 'list')
+export const Table = markdownPlace('Table', 'table')
+export const ThematicBreak = markdownPlace('ThematicBreak', 'thematicBreak')
+export const HtmlBlock = markdownPlace('HtmlBlock', 'html')
+
 type Parsed = {
   readonly type: string
   readonly start: number
@@ -52,7 +63,7 @@ const blankLine = /\n[^\S\n]*\n/
 
 const fence = /^ {0,3}(`{3}|~{3})/
 
-function createReader(): MarkdownReader {
+export function createReader(): MarkdownReader {
   const replies: Reply[] = []
 
   const remember = (reply: Reply) => {
@@ -152,22 +163,7 @@ function plainText(node: Nodes): string {
   return node.children.map(plainText).join(node.type === 'tableRow' ? '\t' : '\n')
 }
 
-function markdownSlot<Type extends RootContent['type']>(name: string, type: Type): MarkdownSlot<BlockProps<Type>> {
-  return { markdown: { name, type, createReader } } as MarkdownSlot<BlockProps<Type>>
-}
-
-export const markdownSlots = {
-  Heading: markdownSlot('Heading', 'heading'),
-  Paragraph: markdownSlot('Paragraph', 'paragraph'),
-  CodeBlock: markdownSlot('CodeBlock', 'code'),
-  BlockQuote: markdownSlot('BlockQuote', 'blockquote'),
-  List: markdownSlot('List', 'list'),
-  Table: markdownSlot('Table', 'table'),
-  ThematicBreak: markdownSlot('ThematicBreak', 'thematicBreak'),
-  HtmlBlock: markdownSlot('HtmlBlock', 'html'),
-}
-
-export function markdownBlocks<S extends MarkdownSlot>(text: string, slot: S): Omit<SlotProps<S>, 'Default'>[] {
-  const blocks = parsed(text, 0).filter((block) => block.type === slot.markdown.type)
-  return blocks.map((block) => block.props) as unknown as Omit<SlotProps<S>, 'Default'>[]
+export function markdownBlocks<P extends MarkdownPlace>(text: string, place: P): Omit<PlaceProps<P>, 'Default'>[] {
+  const blocks = parsed(text, 0).filter((block) => block.type === place.markdown)
+  return blocks.map((block) => block.props) as unknown as Omit<PlaceProps<P>, 'Default'>[]
 }