@nyte-ai/plugin 0.0.25-beta.1 → 0.0.25-nightly.20261101.40

package/dist/src/claude-code-sdk/index.js

@@ -1,29 +1,21 @@
 import {
   findOnPath2
 } from "../../chunks/bash-description-4vz9pxyx.js";
-import {
-  answerInput2
-} from "../../chunks/bash-description-6z2kgtyt.js";
-import {
-  question2
-} from "../../chunks/bash-description-3j77ss7y.js";
 import {
   CLAUDE_CODE_PROVIDER2,
-  MIRROR_TOOL3,
-  BACKGROUND_TOOL2,
   emptyMessage3,
   Translator3
-} from "../../chunks/bash-description-ye3wk5r3.js";
-import {
-  ClaudeCodeSession2
-} from "../../chunks/bash-description-wbe8w0te.js";
+} from "../../chunks/bash-description-bas41ptb.js";
 import {
-  mirrorArguments3,
   userBlocks3,
   messageKey3,
   sessionEntries2,
   flatPrompt2
-} from "../../chunks/bash-description-2v3g7rd9.js";
+} from "../../chunks/bash-description-bj5yh7tr.js";
+import {
+  isolatedOptions2,
+  ClaudeCodeSession2
+} from "../../chunks/bash-description-rxpx004v.js";
 
 // src/claude-code-sdk/index.ts
 import { randomUUID } from "node:crypto";
@@ -42,31 +34,9 @@ import {
   registerSessionResourceCleanup
 } from "@nyte-ai/ai";
 import { processEnvironment } from "@nyte-ai/core";
-import { standard } from "@nyte-ai/schema";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
 var API = "claude-agent-sdk";
 var EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 var NOT_RUNNING = "Claude Code is no longer running this turn. Send a message to continue.";
-var CLAUDE_CODE_HAS_ITS_OWN = new Set([
-  "read",
-  "write",
-  "edit",
-  "list",
-  "web_search",
-  "question"
-]);
-var ultracodeSetting = {
-  id: "claude_code.ultracode",
-  label: "Claude Code ultracode",
-  schema: standard(Type.Boolean()),
-  choices: [
-    { value: false, label: "Off" },
-    { value: true, label: "On", badge: "ultracode" }
-  ],
-  default: false,
-  scope: "session"
-};
 function effortFor(model, reasoning) {
   if (reasoning === undefined)
     return;
@@ -100,22 +70,17 @@ function answerOnce(start, model, context, options) {
   (async () => {
     try {
       stream.push({ type: "start", partial: output });
-      const claude = await findClaudeCode();
       for await (const message of start({
         prompt: flatPrompt2(context.messages),
         options: {
+          ...isolatedOptions2(await findClaudeCode(), options?.env),
           model: model.id,
           abortController: controller,
           systemPrompt: getCurrentSystemPrompt(context.messages),
-          tools: [],
-          settingSources: [],
-          strictMcpConfig: true,
           maxTurns: 1,
           persistSession: false,
           includePartialMessages: true,
-          thinking: { type: "disabled" },
-          env: { ...process.env, ...options?.env },
-          pathToClaudeCodeExecutable: claude
+          thinking: { type: "disabled" }
         }
       })) {
         if (message.type === "stream_event" && message.parent_tool_use_id === null)
@@ -140,112 +105,6 @@ function answerOnce(start, model, context, options) {
   })();
   return stream;
 }
-var nonEmpty = Type.String({ minLength: 1 });
-function field(input, key) {
-  const value = input[key];
-  return Value.Check(nonEmpty, value) ? value : undefined;
-}
-var claudeQuestions = Type.Array(Type.Object({
-  question: Type.String(),
-  header: Type.String(),
-  options: Type.Array(Type.Object({ label: Type.String(), description: Type.String() })),
-  multiSelect: Type.Optional(Type.Boolean())
-}));
-async function askUser(session, id, input, invocation) {
-  if (!Value.Check(claudeQuestions, input.questions))
-    return { answers: null, part: null };
-  const questions = input.questions.map((item) => ({
-    question: item.question,
-    header: item.header.slice(0, 30),
-    options: item.options.map(({ label, description }) => ({ label, description })),
-    multiple: item.multiSelect === true
-  }));
-  const part = await invocation.session.parts.create(question2, {
-    state: { questions, answers: null },
-    placement: { kind: "modal" }
-  });
-  const outcome = await invocation.wait({ kind: "part", part: part.id });
-  const checked = outcome.kind === "part" && outcome.answer?.action === "answer" ? await answerInput2["~standard"].validate(outcome.answer.input) : undefined;
-  if (checked === undefined || checked.issues !== undefined)
-    return { answers: null, part: part.id };
-  const answers = questions.flatMap((item, index) => {
-    const chosen = checked.value.answers[index]?.join(", ") ?? "";
-    return chosen === "" ? [] : [[item.question, chosen]];
-  });
-  return { answers: answers.length === 0 ? null : Object.fromEntries(answers), part: part.id };
-}
-function classifyClaudeTool(name, input) {
-  const path = field(input, "file_path") ?? field(input, "notebook_path");
-  const command = field(input, "command");
-  const description = field(input, "description");
-  switch (name) {
-    case "Read":
-      return path === undefined ? { kind: "custom", label: name } : { kind: "read", path };
-    case "Edit":
-    case "MultiEdit":
-    case "Write":
-    case "NotebookEdit":
-      return path === undefined ? { kind: "custom", label: name } : { kind: "edit", path };
-    case "Bash":
-      if (command === undefined)
-        return { kind: "custom", label: name };
-      return description === undefined ? { kind: "shell", command } : { kind: "shell", command, description };
-    case "Agent":
-    case "Task":
-      return {
-        kind: "delegate",
-        child: null,
-        role: "task",
-        title: description ?? null
-      };
-    case "Skill":
-      return { kind: "custom", label: `Skill ${field(input, "skill") ?? ""}`.trim() };
-    case "Workflow":
-      return {
-        kind: "custom",
-        label: `Workflow ${field(input, "title") ?? field(input, "name") ?? ""}`.trim()
-      };
-    case "AskUserQuestion": {
-      const headers = Value.Check(claudeQuestions, input.questions) ? input.questions.map((item) => item.header).join(", ") : "";
-      return { kind: "custom", label: `Asking ${headers}`.trim() };
-    }
-    case BACKGROUND_TOOL2:
-      return { kind: "custom", label: "Waiting for background work" };
-    default: {
-      const subject = field(input, "pattern") ?? field(input, "url") ?? field(input, "query");
-      return { kind: "custom", label: subject === undefined ? name : `${name} ${subject}` };
-    }
-  }
-}
-function mirrorTool(sessions) {
-  return {
-    name: MIRROR_TOOL3,
-    description: "A tool Claude Code ran. Claude Code reports the result; Nyte records it.",
-    parameters: standard(mirrorArguments3),
-    exposure: "hidden",
-    approval: "runtime",
-    replay: "safe",
-    class: ({ name, input }) => classifyClaudeTool(name, input),
-    async execute({ id, name, input }, invocation) {
-      const session = sessions.get(invocation.session.id);
-      if (session === undefined || session.closed)
-        throw new Error(NOT_RUNNING);
-      if (name === BACKGROUND_TOOL2)
-        return { content: [{ kind: "text", text: await session.background(invocation.signal) }] };
-      session.recording(id);
-      let parts = [];
-      if (name === "AskUserQuestion") {
-        const asked = await askUser(session, id, input, invocation);
-        session.answer(id, asked.answers);
-        parts = asked.part === null ? [] : [asked.part];
-      }
-      const output = await session.result(id, invocation.signal);
-      if (output.isError)
-        throw new Error(output.text);
-      return { content: [{ kind: "text", text: output.text }], parts };
-    }
-  };
-}
 function claudeCodeSdk(start = query) {
   const catalog = anthropicProvider();
   const sessions = new Map;
@@ -264,27 +123,25 @@ function claudeCodeSdk(start = query) {
     if (id === undefined || binding === undefined)
       throw new Error("Claude Code answers inside a Nyte session with the claude-code-sdk plugin.");
     const effort = effortFor(model, options?.reasoning);
-    const ultracode = await binding.ultracode();
-    const key = JSON.stringify([model.id, binding.cwd, options?.reasoning !== undefined]);
+    const system = getCurrentSystemPrompt(context.messages);
+    const key = JSON.stringify([model.id, binding.cwd, options?.reasoning !== undefined, system]);
     const messages = context.messages.filter((message) => message.role !== "system");
     const keys = messages.map(messageKey3);
-    const tools = getCurrentTools(context.messages).filter((tool) => !CLAUDE_CODE_HAS_ITS_OWN.has(tool.name));
-    let session = sessions.get(id);
-    const continues = session !== undefined && !session.closed && !session.asking && session.key === key && session.known.length < keys.length && session.known.every((known, index) => keys[index] === known);
+    const tools = getCurrentTools(context.messages);
     const prompt = messages.slice(messages.findLastIndex((message) => message.role !== "user") + 1);
-    if (!continues) {
+    let session = sessions.get(id);
+    if (session === undefined || !session.follows(key, keys)) {
       session?.close();
       if (prompt.length === 0)
         throw new Error(NOT_RUNNING);
-      const claude = await findClaudeCode();
       const claudeSession = randomUUID();
       session = new ClaudeCodeSession2({
         key,
         model: model.id,
         cwd: binding.cwd,
+        system,
         thinking: options?.reasoning !== undefined,
         effort,
-        ultracode,
         env: options?.env,
         session: claudeSession,
         history: sessionEntries2(messages.slice(0, -prompt.length), {
@@ -294,24 +151,16 @@ function claudeCodeSdk(start = query) {
         }),
         tools,
         query: start,
-        claude,
-        approve: binding.approve
+        claude: await findClaudeCode()
       });
       sessions.set(id, session);
     }
-    if (session === undefined)
-      throw new Error(NOT_RUNNING);
     session.expose(tools);
     session.deliver(messages);
-    await session.configure(effort, ultracode);
+    await session.configure(effort);
     if (prompt.length > 0)
       session.send(prompt.flatMap((message) => message.role === "user" ? userBlocks3(message) : []));
-    const live = session;
-    const stream = live.respond(model, options?.signal);
-    stream.result().then((message) => {
-      live.known = message.stopReason === "error" || message.stopReason === "aborted" ? [] : [...keys, messageKey3(message)];
-    });
-    return stream;
+    return session.respond(model, keys, options?.signal);
   }
   const stream = (model, context, options) => getCurrentTools(context.messages).length === 0 ? answerOnce(start, model, context, options) : lazyStream(model, () => respond(model, context, options));
   const provider = {
@@ -346,17 +195,9 @@ function claudeCodeSdk(start = query) {
   };
   const plugin = {
     id: "claude-code-sdk",
-    contribute: { tools: [mirrorTool(sessions)], settings: [ultracodeSetting] },
     activate(api) {
       const id = api.session.id;
-      const binding = {
-        cwd: api.env.cwd,
-        ultracode: async () => await api.contribute.settings.value(ultracodeSetting.id) === true,
-        approve: async (name, input, signal) => {
-          const verdict = await api.approve({ name, class: classifyClaudeTool(name, input) }, signal);
-          return verdict.kind === "allow" ? { behavior: "allow" } : { behavior: "deny", message: verdict.reason };
-        }
-      };
+      const binding = { cwd: api.env.cwd };
       const release = acquireSessionResources(id);
       bindings.set(id, binding);
       const unbind = () => {
@@ -373,6 +214,5 @@ function claudeCodeSdk(start = query) {
   return { provider, plugin };
 }
 export {
-  claudeCodeSdk,
-  ultracodeSetting
+  claudeCodeSdk
 };

package/dist/src/claude-code-sdk/session.d.ts

@@ -1,50 +1,49 @@
-import type { CanUseTool, EffortLevel, PermissionResult, Query, SDKMessage, SessionStoreEntry, query } from "@anthropic-ai/claude-agent-sdk";
-import type { Api, AssistantMessageEventStream, Message, Model, Tool } from "@nyte-ai/ai";
+import type { EffortLevel, Options, Query, SDKMessage, SessionStoreEntry, query } from "@anthropic-ai/claude-agent-sdk";
+import type { Api, AssistantMessageEventStream, Message, Model, ProviderEnv, Tool } from "@nyte-ai/ai";
 import type { ContentBlock } from "./transcript.ts";
 interface Launch {
+    /** What only a new process can change: model, folder, thinking and system prompt. Effort and tools change on a running one. */
     readonly key: string;
     readonly model: string;
     readonly cwd: string;
+    readonly system: string;
     readonly thinking: boolean;
     readonly effort: EffortLevel | undefined;
-    readonly ultracode: boolean;
-    readonly env: Record<string, string | undefined> | undefined;
+    readonly env: ProviderEnv | undefined;
     readonly session: string;
     readonly history: readonly SessionStoreEntry[];
     readonly tools: readonly Tool[];
     readonly query: StartQuery;
     /** The installed `claude` to run; without one the Agent SDK looks for its own. */
     readonly claude: string | undefined;
-    readonly approve: Approve;
 }
-/** Decides a call Claude Code asks to run under Nyte's permissions policy, by the tool's own name. */
-export type Approve = (name: string, input: Parameters<CanUseTool>[1], signal: AbortSignal) => Promise<PermissionResult>;
 /** Starts Claude Code: the Agent SDK's `query`, or a stand-in with the parts of its `Query` a session uses. */
 export type StartQuery = (params: Parameters<typeof query>[0]) => AsyncIterable<SDKMessage> & Pick<Query, "applyFlagSettings" | "close">;
-export type QuestionAnswers = Record<string, string> | null;
-interface ClaudeToolOutput {
-    readonly text: string;
-    readonly isError: boolean;
-}
+/**
+ * Claude Code as a bare model: only the tools and system prompt Nyte passes, none of the user's
+ * Claude Code settings, hooks, MCP servers, skills or CLAUDE.md, and prompts sent as written
+ * (`verbatimPrompts` needs Claude Code 2.1.248 or later).
+ */
+export declare function isolatedOptions(claude: string | undefined, env: ProviderEnv | undefined): Options;
+/**
+ * One running `claude` for a Nyte session. Claude's calls to Nyte's tools end the response that
+ * makes them; Nyte runs them like any model's calls, and their results answer Claude's MCP
+ * requests when the next response starts.
+ */
 export declare class ClaudeCodeSession {
     #private;
-    readonly key: string;
-    known: readonly string[];
     constructor(launch: Launch);
     get closed(): boolean;
-    configure(effort: EffortLevel | undefined, ultracode: boolean): Promise<void>;
+    /** Whether this process can take the turn for `keys`: it was launched as `key` and has seen their start. */
+    follows(key: string, keys: readonly string[]): boolean;
+    configure(effort: EffortLevel | undefined): Promise<void>;
     /** Serves `tools` as the Nyte MCP server's tools from now on, telling Claude Code when they changed. */
     expose(tools: readonly Tool[]): void;
-    /** Answers Claude Code from Nyte's tool results: a Nyte tool call gets its result, and a call Claude Code asked to run but Nyte settled without running it is denied with that result. */
+    /** Answers Claude's waiting Nyte tool calls with the results Nyte recorded for them. */
     deliver(messages: readonly Message[]): void;
-    /** Lets Claude Code's call `id` go on to its approval now that Nyte records it (so the workspace snapshot before it is taken), and denies the calls before it in the same message that Nyte settled without running. */
-    recording(id: string): void;
     send(content: readonly ContentBlock[]): void;
-    respond(model: Model<Api>, signal: AbortSignal | undefined): AssistantMessageEventStream;
-    get asking(): boolean;
-    answer(id: string, answers: QuestionAnswers): void;
-    result(id: string, signal: AbortSignal): Promise<ClaudeToolOutput>;
-    background(signal: AbortSignal): Promise<string>;
+    /** Streams Claude's next response to the transcript whose message keys are `keys`. */
+    respond(model: Model<Api>, keys: readonly string[], signal: AbortSignal | undefined): AssistantMessageEventStream;
     close(reason?: Error): void;
 }
 export {};

package/dist/src/claude-code-sdk/session.js

@@ -1,7 +1,10 @@
 import {
+  isolatedOptions2,
   ClaudeCodeSession2
-} from "../../chunks/bash-description-wbe8w0te.js";
-import"../../chunks/bash-description-ye3wk5r3.js";
+} from "../../chunks/bash-description-rxpx004v.js";
+import"../../chunks/bash-description-bj5yh7tr.js";
+import"../../chunks/bash-description-bas41ptb.js";
 export {
-  ClaudeCodeSession2 as ClaudeCodeSession
+  ClaudeCodeSession2 as ClaudeCodeSession,
+  isolatedOptions2 as isolatedOptions
 };

package/dist/src/claude-code-sdk/transcript.d.ts

@@ -1,15 +1,9 @@
 import type { SDKUserMessage, SessionStoreEntry } from "@anthropic-ai/claude-agent-sdk";
 import type { Message, UserMessage } from "@nyte-ai/ai";
-import { Type } from "typebox";
 type MessageParam = Exclude<SDKUserMessage["message"], {
     role: "system";
 }>;
 export type ContentBlock = Exclude<MessageParam["content"], string>[number];
-export declare const mirrorArguments: Type.TObject<{
-    id: Type.TString;
-    name: Type.TString;
-    input: Type.TRecord<"^.*$", Type.TUnknown>;
-}>;
 export declare function userBlocks(message: UserMessage): ContentBlock[];
 export declare function messageKey(message: Message): string;
 export declare function sessionEntries(messages: readonly Message[], input: {

package/dist/src/claude-code-sdk/transcript.js

@@ -1,15 +1,13 @@
 import {
-  mirrorArguments3,
   userBlocks3,
   messageKey3,
   sessionEntries2,
   flatPrompt2
-} from "../../chunks/bash-description-2v3g7rd9.js";
-import"../../chunks/bash-description-ye3wk5r3.js";
+} from "../../chunks/bash-description-bj5yh7tr.js";
+import"../../chunks/bash-description-bas41ptb.js";
 export {
   flatPrompt2 as flatPrompt,
   messageKey3 as messageKey,
-  mirrorArguments3 as mirrorArguments,
   sessionEntries2 as sessionEntries,
   userBlocks3 as userBlocks
 };

package/dist/src/claude-code-sdk/translate.d.ts

@@ -1,18 +1,14 @@
 import type { SDKPartialAssistantMessage } from "@anthropic-ai/claude-agent-sdk";
-import type { Api, AssistantMessage, AssistantMessageEventStream, Model, ToolCall } from "@nyte-ai/ai";
+import type { Api, AssistantMessage, AssistantMessageEventStream, Model } from "@nyte-ai/ai";
 type StreamEvent = SDKPartialAssistantMessage["event"];
 export declare const CLAUDE_CODE_PROVIDER = "claude-code";
-export declare const MIRROR_TOOL = "claude_code";
-export declare const BACKGROUND_TOOL = "BackgroundTasks";
 export declare const NYTE_SERVER = "nyte";
 export declare const NYTE_TOOL_PREFIX = "mcp__nyte__";
 export declare function emptyMessage(model: Model<Api>): AssistantMessage;
-export declare function mirrorCall(id: string, name: string, input: Record<string, unknown>): ToolCall;
 export declare class Translator {
     #private;
     constructor(model: Model<Api>, output: AssistantMessage, stream: AssistantMessageEventStream);
     /** Applies one stream event. Returns the raw stop reason at a message's end, and `"tool_use"` as soon as a Nyte tool call's input is complete: Claude Code waits for Nyte to run it before it runs the message's later calls. */
     apply(event: StreamEvent): string | undefined;
-    append(call: ToolCall): void;
 }
 export {};

package/dist/src/claude-code-sdk/translate.js

@@ -1,20 +1,14 @@
 import {
   CLAUDE_CODE_PROVIDER2,
-  MIRROR_TOOL3,
-  BACKGROUND_TOOL2,
   NYTE_SERVER2,
   NYTE_TOOL_PREFIX2,
   emptyMessage3,
-  mirrorCall2,
   Translator3
-} from "../../chunks/bash-description-ye3wk5r3.js";
+} from "../../chunks/bash-description-bas41ptb.js";
 export {
-  BACKGROUND_TOOL2 as BACKGROUND_TOOL,
   CLAUDE_CODE_PROVIDER2 as CLAUDE_CODE_PROVIDER,
-  MIRROR_TOOL3 as MIRROR_TOOL,
   NYTE_SERVER2 as NYTE_SERVER,
   NYTE_TOOL_PREFIX2 as NYTE_TOOL_PREFIX,
   Translator3 as Translator,
-  emptyMessage3 as emptyMessage,
-  mirrorCall2 as mirrorCall
+  emptyMessage3 as emptyMessage
 };

package/dist/src/client/mount.d.ts

@@ -1,11 +1,12 @@
 import type { Connection, Session } from "@nyte-ai/core";
-import type { Decision, Placement, SessionInfo, SubmitDraft } from "@nyte-ai/schema";
+import type { Decision, Placement, SessionId, SessionInfo, SubmitDraft } from "@nyte-ai/schema";
 import type { Plugin, PluginApi } from "../client.ts";
 import type { PartMessage } from "./presentation.ts";
 type Notification = Parameters<PluginApi["ui"]["notify"]>[0];
 /**
  * What a client hands the plugins it mounts: its connection, the frameworks
- * it draws, the session on screen, and where notices and plugin errors go.
+ * it draws, the session input goes to, the sessions someone is looking at,
+ * and where notices and plugin errors go.
  *
  * @category plugins
  */
@@ -14,6 +15,7 @@ export interface MountOptions {
     readonly plugins: readonly Plugin[];
     readonly client: PluginApi["client"];
     readonly session: () => Session | null;
+    readonly looking: () => ReadonlySet<SessionId>;
     readonly notify: (input: Notification) => void;
     readonly report: (plugin: string, message: string) => void;
 }

package/dist/src/client/mount.js

@@ -173,6 +173,9 @@ async function mountClientPlugins(options) {
       get session() {
         return options.session();
       },
+      get looking() {
+        return options.looking();
+      },
       ui: { notify: options.notify }
     };
     const hooks = plugin.hooks ?? {};

package/dist/src/client/notifications.d.ts

@@ -1,9 +1,10 @@
 import type { RunEnd } from "@nyte-ai/schema";
 /**
- * Tells the user when a run ends in any session this client can see:
- * finished, or failed with the reason. A stopped run stays quiet because
- * someone asked for it, and so do sessions a parent spawned, so a delegation
- * does not ring once per child.
+ * Tells the user when a run ends in a session this client can see but nobody
+ * is looking at: finished, or failed with the reason. A session someone is
+ * looking at shows its own result, a stopped run stays quiet because someone
+ * asked for it, and so do sessions a parent spawned, so a delegation does not
+ * ring once per child.
  *
  * @category plugins
  * @since 0.1.0
@@ -34,3 +35,10 @@ declare const _default: {
     };
 };
 export default _default;
+/**
+ * What to tell the user about a run's end: that it's done, or that it failed and why, on one
+ * line of at most 120 characters. A stopped run says nothing, because someone asked for it.
+ *
+ * @category plugins
+ */
+export declare function describeRunEnd(end: RunEnd): string | undefined;

package/dist/src/client/notifications.js

@@ -1,24 +1,39 @@
+import {
+  taskLabel2,
+  endedStatus2,
+  sessionTitle2
+} from "../../chunks/bash-description-qwyy182r.js";
+
 // src/client/notifications.ts
 var notifications_default = {
   id: "notifications",
   hooks: {
     run_ended_anywhere: async (event, { api }) => {
+      if (api.looking.has(event.session))
+        return;
       const info = await api.sdk.session(event.session).info();
       if (info.parent !== null)
         return;
-      const title = info.name ?? undefined;
-      const { end } = event;
-      if (end.kind === "completed")
-        api.ui.notify({ title, message: "Run finished", level: "info" });
-      else if (end.kind === "failed")
-        api.ui.notify({ title, message: `Run failed: ${line(end)}`, level: "error" });
+      const message = describeRunEnd(event.end);
+      if (message !== undefined)
+        api.ui.notify({
+          title: sessionTitle2(info),
+          message,
+          level: event.end.kind === "failed" ? "error" : "info"
+        });
     }
   }
 };
-function line(end) {
-  const text = end.failure.message.replace(/\s+/g, " ").trim();
-  return text.length > 120 ? `${text.slice(0, 119)}…` : text;
+function describeRunEnd(end) {
+  const status = endedStatus2(end);
+  if (status.kind === "completed")
+    return taskLabel2("done");
+  if (status.kind !== "failed")
+    return;
+  const text = status.failure.message.replace(/\s+/g, " ").trim();
+  return `${taskLabel2("failed")}: ${text.length > 120 ? `${text.slice(0, 119)}…` : text}`;
 }
 export {
-  notifications_default as default
+  notifications_default as default,
+  describeRunEnd
 };