@cmodjs/core 1.6.0 → 2.0.1

package/testing.js

@@ -1,14 +1,21 @@
 import { readSteps, storeFolder } from './records.js';
 import { answerCall, cmodPluginName, notInstalled } from './runtime/dependencies.js';
-import { foldAnswers, installBefore } from './runtime/before.js';
+import { foldBefore, installBefore } from './runtime/before.js';
+import { permissionRoutes } from './runtime/permission-check.js';
+import { keepClaudeCode } from './testing/claude-code.js';
 import { createRouter } from './runtime/router.js';
 import { toolInputOf } from './runtime/tool-calls.js';
 import { createLifecycle } from './runtime/lifecycle.js';
 import { MissingOptions } from './runtime/options.js';
 import { conversationMethods } from './runtime/sessions.js';
+import { 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 { TurnEnd } from './session/context/turn/turn.js';
+import { beforeEvents, processEvents, sessionEvents } from './session/session.js';
+import { ContextEnd } from './session/context/context.js';
+import { TaskStart } from './session/goal/task.js';
 import { calledAnswer, fakeClaude } from './testing/fake-claude.js';
 import { elements, findElement, rowsOf } from './testing/fake-elements.js';
 import { fakeFiles } from './testing/fake-files.js';
@@ -37,6 +44,7 @@ export function testMod(definition, options = {}) {
     const conversations = fakeSessions({
         callTool: (args) => fake.claude.tool.call(args),
         project: () => projectRoot,
+        cwd: () => cwd,
         given: options.sessions ?? [],
         push: (mod, session, change) => {
             if (mod !== name)
@@ -72,7 +80,7 @@ export function testMod(definition, options = {}) {
     const starting = options.state;
     const declared = Object.entries(definition.state ?? {});
     const state = Object.fromEntries(declared.map(([lifetime, values]) => [lifetime, { ...values, ...starting?.[lifetime] }]));
-    const lifecycle = createLifecycle({ ...definition, state }, () => true, (options.options ?? {}), false);
+    const lifecycle = createLifecycle({ ...definition, state }, () => permissionRoutes, (options.options ?? {}), false);
     let started;
     const start = async () => {
         started ??= lifecycle.start(fake.claude, async (claude) => {
@@ -109,7 +117,7 @@ export function testMod(definition, options = {}) {
         hooks: {
             place: async () => conversations.place(),
             wants: async (event) => conversations.wants(name, event),
-            decide: (event, change) => foldAnswers(event, change, [(latest) => askMod(event, latest)], (error) => fake.claude.ui.log(`cmod: passed the ${event} on without ${name}'s answer: ${messageOf(error)}`, { to: 'debug' })),
+            decide: (event, change) => foldBefore(event, change, [(latest) => askMod(event, latest)], (error) => fake.claude.ui.log(`cmod: passed the ${event} on without ${name}'s answer: ${messageOf(error)}`, { to: 'debug' })),
         },
     });
     const route = async (event, input, below) => {
@@ -162,6 +170,40 @@ export function testMod(definition, options = {}) {
             return route(`classic.${event}`, filled, below);
         return firePreToolUse(filled, below);
     });
+    const asked = async (event, change) => {
+        await start();
+        return (await askMod(event, change)) ?? undefined;
+    };
+    const raise = Object.fromEntries([
+        ...beforeEvents
+            .filter((named) => named !== 'TaskStart' && named !== 'TurnEnd' && named !== 'ContextEnd')
+            .map((named) => [`before${named}`, async (draft, placed) => {
+                await start();
+                return asked(sessionEvents[named], { type: Message, message: conversations.draft({ ...draft, type: sessionEvents[named] }, placed?.task) });
+            }]),
+        ['beforeTaskStart', async ({ title, agentType = 'general-purpose', model }) => {
+                await start();
+                return asked(TaskStart, { type: TaskStart, task: { id: '', title, agentType, openedBy: '', openedAt: new Date().toISOString(), context: conversations.place().context, ...(model === undefined ? {} : { model }) } });
+            }],
+        ['beforeTurnEnd', async (ending = {}) => {
+                await start();
+                const { turn } = conversations.place();
+                if (turn === undefined)
+                    throw new Error(`${name} has no turn open to end. Open one with tested.add({ type: Prompt, text: '…' }).`);
+                return asked(TurnEnd, { type: TurnEnd, turn: { ...turn, ...ending, closedAt: new Date().toISOString() } });
+            }],
+        ['beforeContextEnd', async () => {
+                await start();
+                const { context, contextOpenedAt } = conversations.place();
+                return asked(ContextEnd, { type: ContextEnd, context: { number: context, openedAt: contextOpenedAt, closedAt: new Date().toISOString() } });
+            }],
+        ...[...Object.entries(processEvents).flatMap(([named, event]) => [`on${named}`, ...('before' in event ? [`before${named}`] : [])]), 'onRun', 'beforeRun'].map((method) => [method, async (payload) => {
+                await start();
+                const answer = await lifecycle.raise(method, { session: sessionId, cwd, ...payload });
+                await fake.settle();
+                return answer;
+            }]),
+    ]);
     const firePreToolUse = async ({ tool_name, tool_input, tool_use_id, agent_id, agent_type }, below) => {
         await start();
         if (agent_id !== undefined && agent_type !== undefined)
@@ -187,22 +229,28 @@ export function testMod(definition, options = {}) {
         await fake.settle();
         return value;
     };
-    return {
+    const tested = {
         start,
+        raise,
         fire,
         settle: fake.settle,
         add: async (message, added) => {
             await start();
             return settled(conversations.add(message, added?.task));
         },
-        endTurn: async () => {
+        endTurn: async (ending) => {
             await start();
-            await settled(conversations.endTurn());
+            await settled(conversations.endTurn(ending === undefined ? undefined : { ...ending, ...(ending.failure === undefined ? {} : { reason: 'error' }) }));
         },
         compact: async () => {
             await start();
             await settled(conversations.compact());
         },
+        startSession: async ({ source, id }) => {
+            await start();
+            await fire('SessionStart', { source, ...(id === undefined ? {} : { session_id: id }) });
+            await fake.settle();
+        },
         startTask: async (task) => {
             await start();
             return settled(conversations.startTask(task));
@@ -283,7 +331,7 @@ export function testMod(definition, options = {}) {
         get state() {
             const mod = lifecycle.mod;
             if (mod === undefined)
-                throw new Error(`${name} has not started. Await tested.start() or tested.fire(…) first.`);
+                throw new Error(`${name} has not started. Await tested.start() first.`);
             return mod.state;
         },
         calls: fake.calls,
@@ -296,6 +344,8 @@ export function testMod(definition, options = {}) {
             sent: conversations.sent,
         },
     };
+    keepClaudeCode(tested, { fire });
+    return tested;
 }
 function fakeDependencies(caller, dependencies, conversations) {
     const cmod = { forkParent: () => null, updateSettings: () => null };
@@ -323,7 +373,7 @@ function plainOutput({ component, props }) {
     return elements.Box({ flexDirection: 'column', children: [elements.Text({ children: component }), elements.Box({ flexDirection: 'column', paddingLeft: 2, children: rows })] });
 }
 function replyOf({ text, context }) {
-    return { ...(text === undefined ? {} : { text }), ...(context === undefined ? {} : { context: context.join('\n') }) };
+    return { ...(text === undefined ? {} : { text }), ...(context === undefined ? {} : { note: context.join('\n') }) };
 }
 async function modSteps() {
     const manifest = '../../../package.json';

package/docs/hooks.md

@@ -1,259 +0,0 @@
-# Hooks
-
-A hook is a point where Claude Code asks its plugins, such as a prompt or a tool call. `mod.on` runs a listener at a hook. The listener reads the hook's input and may answer to change what Claude Code does next.
-
-## mod.on
-
-```ts
-mod.on<H extends Hook>(hook: H, listener: HookListener<H>, options?: { timeoutMs?: number }): Disposable
-mod.on<H extends Hook>(hook: H, matcher: Matcher<HookInput<H>>, listener: HookListener<H>, options?: { timeoutMs?: number }): Disposable
-
-type HookListener<H> = (input: HookInput<H>) => HookAnswer | void | Promise<HookAnswer | void>
-```
-
-Add listeners in `setup`. Each `mod.on` adds one more listener. Several listeners on one hook all run. `dispose()` on the `Disposable` it returns removes the listener ([mod.md](mod.md#disposable)).
-
-`mod.js` exports each hook's name as a constant, such as `PreToolUse`, and `mod.on` takes it: `mod.on(PreToolUse, …)`.
-
-A matcher runs the listener only for the inputs it matches. It is a partial copy of the input: a key it names must match, and a key it leaves out matches anything. A string matches the same string, a `RegExp` matches the text it tests true on, and a list matches any one of its items.
-
-```ts
-mod.on(PostToolUse, { tool_name: /^(Edit|Write)$/ }, ({ files }) => void (mod.state.session.edited += files.changed.length))
-mod.on(PreToolUse, { tool_name: 'Bash', tool_input: { command: /^rm / } }, () => ({ decision: 'block', reason: 'Use trash instead of rm.' }))
-```
-
-A listener that waits on something slow, such as a model call or a server, takes `timeoutMs`. Past it, the hook goes on as if the listener were absent, and cmod shows the warning toast `The <hook> hook passed its <n> s timeout`. Claude Code also gives a listener's own code 10 seconds, and the time it waits on a call does not count toward those 10 seconds, so `timeoutMs` is the limit on a slow call. `timeoutMs` is a whole number above 0 and at most `2147483647`, and any other value stops `setup` with the fix.
-
-```ts
-mod.on(Stop, async ({ last_assistant_message }) => {
-  const verdict = await model.complete({ model: 'haiku', prompt: `Is this reply complete? Answer yes or no.\n\n${last_assistant_message}` })
-  if (verdict.isAnswered && verdict.text.trim().toLowerCase().startsWith('no')) return { decision: 'block', reason: 'Finish the reply.' }
-}, { timeoutMs: 8000 })
-```
-
-`HookInput<H>`, exported from `mod.js`, is the input a listener on `H` gets, for a listener that lives in a function of its own:
-
-```ts
-import { process, SessionStart, type HookAnswer, type HookInput } from '../node_modules/@cmodjs/core/mod.js'
-
-export async function addBranch(input: HookInput<typeof SessionStart>): Promise<HookAnswer | undefined> {
-  const { stdout } = await process.run(['git', 'branch', '--show-current'], { cwd: input.cwd })
-  return { hookSpecificOutput: { hookEventName: SessionStart, additionalContext: `The git branch is ${stdout.trim()}.` } }
-}
-```
-
-A `PreToolUse` hook runs on Claude Code's `tool.call`, before Claude Code checks the call's permission. It rewrites the call's input, adds context to it, or denies it, and Claude Code's permission check sees the rewritten input. A `permissionDecision` of `'allow'` or `'ask'` decides the call's permission, so it takes effect in Claude Code's permission check, and only when the mod's `hooks/register.ts` calls `registerPermissionCheck(addHook)` after `registerMod` ([mod.md](mod.md)):
-
-- `'allow'` runs the call without asking the person, and `'ask'` asks them, with `permissionDecisionReason` as the question's reason.
-- A deny from a settings rule or another hook still denies the call, and the mod's own `permissions` job can still ask or deny.
-- Without `registerPermissionCheck`, an `'allow'` or `'ask'` denies the call with `<mod>: the PreToolUse hook answered permissionDecision "allow", so hooks/register.ts must call registerPermissionCheck(addHook) after registerMod.`
-
-A hook on `PermissionRequest` takes part in that check too, so a mod with one does not start without `registerPermissionCheck`.
-
-```ts
-import { defineMod, PreToolUse } from '../node_modules/@cmodjs/core/mod.js'
-
-export const safeDelete = defineMod({
-  name: 'safe-delete',
-  setup(mod) {
-    mod.on(PreToolUse, (input) => {
-      const command = input.tool_input['command']
-      if (input.tool_name !== 'Bash' || typeof command !== 'string' || !command.startsWith('rm ')) return
-      return { hookSpecificOutput: { hookEventName: PreToolUse, updatedInput: { ...input.tool_input, command: command.replace(/^rm /, 'trash ') } } }
-    })
-  },
-})
-```
-
-## Every hook
-
-`Hook` names the 33 hooks a mod listens to, every hook Claude Code has. The input of each is the input a `settings.json` hook reads, typed as `ClassicHookInputs['<hook>']` in the `claude-code` module, with the changes this table names.
-
-| Hook | Input changes |
-| --- | --- |
-| `Setup` | none |
-| `SessionStart` | none |
-| `SessionEnd` | none |
-| `UserPromptSubmit` | none |
-| `UserPromptExpansion` | none |
-| `InstructionsLoaded` | none |
-| `ConfigChange` | none |
-| `DirectoryAdded` | none |
-| `PreModelSwitch` | none |
-| `PostModelSwitch` | none |
-| `PreToolUse` | Claude Mod Manager (cmod) builds the input: `session_id`, `cwd`, `hook_event_name`, `tool_name`, `tool_input`, `tool_use_id`, `agent_id` inside a subagent, `agent_type` inside a subagent or when the session started as an agent, and `files`. It has no `transcript_path` and no `permission_mode`. |
-| `PermissionRequest` | none |
-| `PermissionDenied` | none |
-| `PostToolUse` | adds `files` |
-| `PostToolUseFailure` | adds `files` |
-| `PostToolBatch` | none |
-| `MessageDisplay` | none |
-| `SubagentStart` | none |
-| `SubagentStop` | none |
-| `TodoCreated` | none |
-| `TodoCompleted` | none |
-| `TeammateIdle` | none |
-| `Elicitation` | none |
-| `ElicitationResult` | none |
-| `Notification` | none |
-| `PreCompact` | none |
-| `PostCompact` | none |
-| `Stop` | none |
-| `StopFailure` | none |
-| `CwdChanged` | no `transcript_path` |
-| `FileChanged` | none |
-| `WorktreeCreate` | none |
-| `WorktreeRemove` | none |
-
-`TodoCreated` and `TodoCompleted` are Claude Code's `TaskCreated` and `TaskCompleted` hooks, under names that say what they hear: an item added to or checked off Claude Code's todo checklist, which its `TaskCreate`, `TaskUpdate`, and `TaskList` tools keep. A cmod `Task` is work handed to another session ([session.md](session.md#turn-context-goal-and-task)), and these hooks never hear one.
-
-cmod raises `CwdChanged` itself, never Claude Code. It raises it when the working folder changes: after `/cd`, after a Bash or PowerShell call, and at a prompt. `sessions.current.cwd` and `sessions.current.project` already hold the new folder when the listener runs.
-
-Claude Code raises `FileChanged` when a file it watches changes, with the file's `file_path` and `event`: `'change'`, `'add'`, or `'unlink'`. It watches the paths a `SessionStart` hook answers in `watchPaths`:
-
-```ts
-mod.on(SessionStart, () => ({ hookSpecificOutput: { hookEventName: SessionStart, watchPaths: [`${mod.dataFolder}/history`] } }))
-mod.on(FileChanged, ({ file_path, event }) => mod.ui.toast(`${file_path}: ${event}`))
-```
-
-## files: what a tool call reads and changes
-
-The input of `PreToolUse`, `PostToolUse`, and `PostToolUseFailure` has `files: { read: string[]; changed: string[] }`, absolute paths that cmod works out from the call:
-
-- `Read` reads its `file_path`. `Edit`, `Write`, and `NotebookEdit` change their path.
-- `Grep` counts its `path`, or the working folder when it names none, and `Glob` counts its `pattern` joined to its `path`. Since `read` lists only files, a `Grep` of a folder and every `Glob` usually leave `read` empty.
-- A `Bash` command reads and changes the files its commands name, such as `cat a.ts > b.ts`. A path that holds a shell expansion, such as `$HOME`, is left out.
-- `read` lists only paths that are files now. `changed` lists every path the call writes, whether it exists or not.
-- A path cmod cannot check, such as one it has no permission to read, is left out of `read`, and cmod writes the path and the reason to Claude Code's debug log.
-- When cmod cannot work the files out, both lists are empty, and the reason goes to Claude Code's debug log.
-
-## shell.js and path.js: read a command line
-
-`shell.js` reads a Bash line the way cmod does for `files`, and `path.js` is `node:path`'s POSIX functions, which a mod cannot import from Node:
-
-```ts
-parseShell(line: string): ParsedShell
-
-type ParsedShell = { commands: ShellCommand[]; reads: string[]; writes: string[]; fetches: string[]; isFullyParsed: boolean }
-type ShellCommand = { argv: [string, ...string[]]; folder: string; input?: number }
-
-resolve(...paths): string   join(...paths): string   dirname(path): string   basename(path, suffix?): string
-extname(path): string        relative(from, to): string   isAbsolute(path): boolean   normalize(path): string
-```
-
-- `commands` lists every command the line runs, those inside `sudo`, `bash -c`, `$(…)`, and heredocs included, with flags such as `-rf` split into `-r` and `-f`.
-- `folder` is where a command runs, as the line wrote it: `''` for the folder the line starts in, `src` after `cd src`, `/tmp` after `cd /tmp`, and `~/p` after `cd ~/p`. `resolve(input.cwd, folder)` makes it absolute.
-- `input` is the index in `commands` of the command whose output this one reads through `|` or `|&`, and is absent for a command that reads no pipe. `trace read a.ts | head -5` gives `head` the `input` `0`. A wrapper such as `timeout 5 trace read a.ts` writes the output of the command it runs, so `input` names `trace`, not `timeout`.
-- `reads`, `writes`, and `fetches` are the paths and URLs the commands name, as written. A path that holds a shell expansion makes `isFullyParsed` false, and so does a line the parser cannot read.
-- `resolve` has no working folder to start from in Claude Code's hooks, so pass an absolute folder first, such as `resolve(sessions.current.cwd, path)`.
-
-```ts
-import { basename, resolve } from '../node_modules/@cmodjs/core/path.js'
-import { parseShell } from '../node_modules/@cmodjs/core/shell.js'
-import { PreToolUse } from '../node_modules/@cmodjs/core/mod.js'
-
-mod.on(PreToolUse, (input) => {
-  if (input.tool_name !== 'Bash') return
-  for (const { argv, folder } of parseShell(String(input.tool_input['command'])).commands) {
-    if (basename(argv[0]) === 'trace') mod.ui.toast(`trace runs in ${resolve(input.cwd, folder)}`)
-  }
-})
-```
-
-## HookAnswer: what a hook can answer
-
-Return nothing to leave the event as it is. Return a `HookAnswer` to change it. The fields are the ones a `settings.json` hook writes as JSON:
-
-```ts
-type HookAnswer = {
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-  decision?: 'block'
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName?: Hook
-    additionalContext?: string
-    permissionDecision?: 'allow' | 'deny' | 'ask'
-    permissionDecisionReason?: string
-    updatedInput?: Record<string, unknown>
-    sessionTitle?: string
-    suppressOriginalPrompt?: boolean
-    initialUserMessage?: string
-    watchPaths?: string[]
-    reloadSkills?: boolean
-    decision?: PermissionRequestDecision
-    updatedToolOutput?: unknown
-    updatedMCPToolOutput?: unknown
-    retry?: boolean
-    displayContent?: string
-    worktreePath?: string
-  }
-}
-```
-
-- `continue: false` stops the session after the event, and `stopReason` is the text Claude Code shows. `PreToolUse` takes neither.
-- `decision: 'block'` with a `reason` blocks the event. On `PreToolUse` it denies the call with the reason. On `Stop` it keeps Claude going with the reason.
-- `systemMessage` shows the text to the person as a log line.
-- cmod ignores `suppressOutput`.
-- `hookSpecificOutput.hookEventName` is optional. When set, it must be the event's own name.
-
-Each event reads only some `hookSpecificOutput` fields:
-
-| Event | `hookSpecificOutput` fields it reads |
-| --- | --- |
-| `SessionStart` | `additionalContext`, `initialUserMessage`, `sessionTitle`, `watchPaths`, `reloadSkills` |
-| `UserPromptSubmit` | `additionalContext`, `sessionTitle`, `suppressOriginalPrompt` |
-| `UserPromptExpansion` | `additionalContext`, `suppressOriginalPrompt` |
-| `PreModelSwitch` | `permissionDecision`, `permissionDecisionReason` |
-| `PreToolUse` | `additionalContext`, `permissionDecision` (`'allow'` and `'ask'` need `registerPermissionCheck`), `permissionDecisionReason`, `updatedInput` |
-| `PermissionRequest` | `decision` |
-| `PermissionDenied` | `retry` |
-| `PostToolUse` | `additionalContext`, `updatedToolOutput`, `updatedMCPToolOutput` |
-| `MessageDisplay` | `displayContent`: the text the person sees in place of the message |
-| `WorktreeCreate` | `worktreePath`: the worktree the hook made, in place of Claude Code's own |
-| `Setup`, `PostModelSwitch`, `PostToolUseFailure`, `PostToolBatch`, `SubagentStart`, `SubagentStop`, `Stop` | `additionalContext` |
-| `SessionEnd`, `InstructionsLoaded`, `ConfigChange`, `DirectoryAdded`, `TodoCreated`, `TodoCompleted`, `TeammateIdle`, `Elicitation`, `ElicitationResult`, `Notification`, `PreCompact`, `PostCompact`, `StopFailure`, `CwdChanged`, `FileChanged`, `WorktreeRemove` | none |
-
-A field the event does not read is an error: `it answered hookSpecificOutput.<field>, which <event> does not read. Remove it from the answer.` A flag set to `false`, such as `retry: false`, counts as unset.
-
-## How answers combine
-
-Every mod's hooks and Claude Code's own `settings.json` hooks answer the same event.
-
-- `additionalContext` from every hook reaches Claude, each in turn.
-- `PreToolUse` hooks run one inside the next, in the order mods and `mod.on` added them. A deny stops the call there, so no hook after it runs. `updatedInput` replaces the tool's input for every hook after it and for Claude Code. `additionalContext` reaches Claude with the call's result, and not at all when Claude Code refuses the call.
-- For every other field, the mod's answer replaces the answer of the hooks beneath it.
-
-```ts
-import { defineMod, Stop } from '../node_modules/@cmodjs/core/mod.js'
-
-export const keepGoing = defineMod({
-  name: 'keep-going',
-  state: { session: { hasCheckedTests: false } },
-  setup(mod) {
-    mod.on(Stop, () => {
-      if (mod.state.session.hasCheckedTests) return
-      mod.state.session.hasCheckedTests = true
-      return { decision: 'block', reason: 'Run the tests before you stop.' }
-    })
-  },
-})
-```
-
-## When a hook fails
-
-A hook that throws, rejects, or answers a field its event does not read fails:
-
-- On `PreToolUse` the call is denied with `<mod>: the PreToolUse hook failed: <error>`.
-- On `PermissionRequest` the request is denied with `<mod>: the PermissionRequest hook failed: <error>`.
-- On every other hook cmod shows the error toast `The <hook> hook failed` with the error under it, and the hook goes on as if the listener answered nothing.
-
-## The first SessionStart
-
-A mod that is still installing when the session starts misses Claude Code's `SessionStart`. cmod holds `SessionStart` up to 9 seconds for the mod to start. When the mod starts later, cmod runs its `SessionStart` hooks then, and Claude Code no longer reads their answer.
-
-## Test a hook
-
-`tested.fire(event, input)` runs the mod's hooks on an event and returns the combined answer. It fills `session_id`, `transcript_path`, `cwd`, `hook_event_name`, and `tool_use_id`, so a test gives only the event's own fields. [testing.md](testing.md) covers it.

package/session/context/turn/message/document.d.ts

@@ -1,7 +0,0 @@
-import type { MessageOf } from './message.js';
-export declare const Document = "document";
-export type Document = MessageOf<typeof Document> & {
-    readonly path: string;
-    readonly text: string;
-};
-//# sourceMappingURL=document.d.ts.map

package/session/context/turn/message/document.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../../../../src/session/context/turn/message/document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,eAAO,MAAM,QAAQ,aAAa,CAAA;AAElC,MAAM,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,QAAQ,CAAC,GAAG;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAA"}

package/session/context/turn/message/document.js

@@ -1 +0,0 @@
-export const Document = 'document';

package/src/session/context/turn/message/document.ts

@@ -1,8 +0,0 @@
-import type { MessageOf } from './message.js'
-
-export const Document = 'document'
-
-export type Document = MessageOf<typeof Document> & {
-  readonly path: string
-  readonly text: string
-}