blume 0.2.0 → 0.4.0

package/src/cli/internal-error.ts

@@ -0,0 +1,63 @@
+import { getBlumeVersion } from "../core/version.ts";
+
+const ESC = String.fromCodePoint(27);
+const DIM = `${ESC}[2m`;
+const RED = `${ESC}[31m`;
+const BOLD = `${ESC}[1m`;
+const RESET = `${ESC}[0m`;
+
+const ISSUES_URL = "https://github.com/haydenbleasel/blume/issues";
+
+// Absolute paths into the hidden generated runtime (`…/.blume/…`), including any
+// trailing `:line:col`, stopping at whitespace or a closing paren.
+const BLUME_FRAME = /(?<abs>\/[^\s()]*\/\.blume\/[^\s()]*)/gu;
+
+/**
+ * Rewrite `.blume/` frames in a stack so the generated runtime reads clearly:
+ * the machine-absolute prefix is dropped to a project-relative `.blume/…` path
+ * and tagged `(generated)`, keeping the reader oriented instead of staring at a
+ * long path into a hidden directory. Frames in the user's own source (custom
+ * pages keep their real location; wrappers import user files by their real path)
+ * are untouched, so the actionable frame stays intact.
+ */
+export const remapBlumeStack = (stack: string): string =>
+  stack.replaceAll(BLUME_FRAME, (match) => {
+    const marker = match.indexOf("/.blume/");
+    return `${match.slice(marker + 1)} (generated)`;
+  });
+
+/**
+ * Print an unexpected (non-{@link BlumeError}) failure in a stable, reportable
+ * shape instead of a bare stack trace: a fixed `BLUME_INTERNAL` code, the
+ * message, a trimmed stack, and an environment dump for bug reports. Callers
+ * exit after this — it doesn't exit itself, so it's testable.
+ */
+export const reportInternalError = (error: unknown): void => {
+  const err = error instanceof Error ? error : new Error(String(error));
+  const lines = [
+    `${RED}${BOLD}BLUME_INTERNAL${RESET} An unexpected error occurred.`,
+    `  ${err.message}`,
+  ];
+
+  // A few frames are enough to locate the fault without burying the report;
+  // `.blume/` frames are relativized so the hidden runtime reads clearly.
+  const stack = remapBlumeStack(err.stack ?? "")
+    .split("\n")
+    .slice(1, 5)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  if (stack.length > 0) {
+    lines.push("", `${DIM}${stack.join("\n")}${RESET}`);
+  }
+
+  lines.push(
+    "",
+    "This is likely a bug in Blume. Please report it with the details below:",
+    `  ${DIM}Blume:    ${getBlumeVersion()}`,
+    `  Node:     ${process.version}`,
+    `  Platform: ${process.platform} ${process.arch}${RESET}`,
+    `  ${ISSUES_URL}`
+  );
+
+  process.stderr.write(`${lines.join("\n")}\n`);
+};

package/src/cli/log.ts

@@ -1,7 +1,9 @@
 import { consola } from "consola";
+import { relative } from "pathe";
 
 import {
   countBySeverity,
+  enrichDiagnostic,
   formatDiagnostic,
   hasErrors,
 } from "../core/diagnostics.ts";
@@ -9,6 +11,42 @@ import type { Diagnostic } from "../core/types.ts";
 
 export const logger = consola.withTag("blume");
 
+/**
+ * Resolve once stdout has drained. `process.exit` doesn't flush a piped stdout,
+ * so await this before exiting non-zero after writing machine-readable output
+ * (e.g. `--json`), otherwise the payload can be truncated in CI.
+ */
+export const flushStdout = (): Promise<void> =>
+  // oxlint-disable-next-line promise/avoid-new -- adapt stdout's write callback
+  new Promise((resolve) => {
+    process.stdout.write("", () => resolve());
+  });
+
+/**
+ * Print diagnostics as a JSON document on stdout for CI and editors: each is
+ * enriched with its `docsUrl` and its `file` made root-relative. Returns whether
+ * any were errors, matching {@link reportDiagnostics}.
+ */
+export const reportDiagnosticsJson = (
+  diagnostics: Diagnostic[],
+  root?: string
+): boolean => {
+  const enriched = diagnostics.map((diagnostic) => {
+    const withDocs = enrichDiagnostic(diagnostic);
+    return withDocs.file && root
+      ? { ...withDocs, file: relative(root, withDocs.file) }
+      : withDocs;
+  });
+  process.stdout.write(
+    `${JSON.stringify(
+      { diagnostics: enriched, summary: countBySeverity(diagnostics) },
+      null,
+      2
+    )}\n`
+  );
+  return hasErrors(diagnostics);
+};
+
 /** Print a batch of diagnostics and return whether any were errors. */
 export const reportDiagnostics = (
   diagnostics: Diagnostic[],
@@ -19,7 +57,9 @@ export const reportDiagnostics = (
   }
 
   for (const diagnostic of diagnostics) {
-    process.stderr.write(`${formatDiagnostic(diagnostic, root)}\n`);
+    process.stderr.write(
+      `${formatDiagnostic(enrichDiagnostic(diagnostic), root)}\n`
+    );
   }
 
   const counts = countBySeverity(diagnostics);

package/src/cli/prepare.ts

@@ -1,10 +1,16 @@
 import { generateRuntime } from "../astro/generate.ts";
 import { BlumeError, hasErrors } from "../core/diagnostics.ts";
 import { scanProject } from "../core/project-graph.ts";
-import type { BlumeProject, BuildMode } from "../core/project-graph.ts";
+import type {
+  BlumeProject,
+  BuildMode,
+  ConfigOverrides,
+} from "../core/project-graph.ts";
 import { serverFeatures } from "../core/server-features.ts";
 import { loadEnvFiles } from "./env.ts";
+import { reportInternalError } from "./internal-error.ts";
 import { logger, reportDiagnostics } from "./log.ts";
+import { checkRequiredSecrets } from "./required-secrets.ts";
 
 export interface PrepareOptions {
   root: string;
@@ -16,6 +22,8 @@ export interface PrepareOptions {
   preview?: boolean;
   /** Force remote sources to re-fetch instead of serving the cached snapshot. */
   refresh?: boolean;
+  /** CLI config overrides (e.g. `--output`, `--content-dir`). */
+  overrides?: ConfigOverrides;
 }
 
 /**
@@ -34,15 +42,17 @@ export const prepareProject = async (
     project = await scanProject(options.root, {
       devServerUrl: options.devServerUrl,
       mode: options.mode,
+      overrides: options.overrides,
       preview: options.preview,
       refresh: options.refresh,
     });
   } catch (error) {
     if (error instanceof BlumeError) {
       reportDiagnostics([error.diagnostic], options.root);
-      process.exit(1);
+    } else {
+      reportInternalError(error);
     }
-    throw error;
+    process.exit(1);
   }
 
   // Hard gate: server-only features cannot ship in a static build.
@@ -81,5 +91,9 @@ export const prepareProject = async (
   for (const warning of warnings) {
     logger.warn(warning);
   }
+
+  // Fail-fast on missing runtime secrets: warn now, not at the first request.
+  reportDiagnostics(checkRequiredSecrets(project.config), options.root);
+
   return project;
 };

package/src/cli/required-secrets.ts

@@ -0,0 +1,44 @@
+import { resolveAskBackend } from "../ai/ask.ts";
+import type { ResolvedConfig } from "../core/schema.ts";
+import type { Diagnostic } from "../core/types.ts";
+
+/**
+ * Warn early when an enabled feature needs a secret env var that isn't set, so
+ * the failure surfaces at `blume dev`/`build` instead of at the first request in
+ * production. These are runtime secrets (the endpoint reads them on the server),
+ * so this warns rather than hard-fails — the value may live only in the deploy
+ * environment. Build-time secrets (search-index sync) already warn during sync.
+ */
+export const checkRequiredSecrets = (config: ResolvedConfig): Diagnostic[] => {
+  const diagnostics: Diagnostic[] = [];
+  const requireSecret = (feature: string, env: string, note?: string): void => {
+    if (process.env[env]) {
+      return;
+    }
+    diagnostics.push({
+      code: "BLUME_MISSING_SECRET",
+      message: `${feature} is enabled but ${env} is not set${note ? ` (${note})` : ""}.`,
+      severity: "warning",
+      suggestion: `Set ${env} in .env.local for local dev, or in your host's environment for production.`,
+    });
+  };
+
+  if (config.ai.ask?.enabled) {
+    const backend = resolveAskBackend(config.ai.ask);
+    if (backend.kind === "gateway") {
+      requireSecret(
+        "Ask AI (AI Gateway)",
+        "AI_GATEWAY_API_KEY",
+        "on Vercel the gateway can also authenticate via OIDC"
+      );
+    } else {
+      requireSecret("Ask AI", backend.apiKeyEnv);
+    }
+  }
+
+  if (config.search.provider === "mixedbread") {
+    requireSecret("Mixedbread search", "MIXEDBREAD_API_KEY");
+  }
+
+  return diagnostics;
+};

package/src/components/BlumePage.astro

@@ -0,0 +1,109 @@
+---
+// Render a Blume content entry's body inside a custom page — e.g. to feature a
+// doc on a landing page, or build a bespoke index that still shows real content.
+//
+//   import BlumePage from "blume/components/BlumePage.astro";
+//   import data from "blume:data";
+//   import { getBlumeCollection } from "blume/runtime";
+//   const [intro] = getBlumeCollection(data, { prefix: "/docs" });
+//   ---
+//   <BlumePage id={intro.entryId} />
+//
+// Blume's built-in MDX components are wired in so callouts, cards, steps, etc.
+// render as they do on a normal page. Pass `components` to add your own overrides
+// or islands (which live in the generated runtime and aren't imported here). The
+// heavy, opt-in `<Math>` component is not included by default — pass it if the
+// embedded content uses math.
+import { getEntry, render } from "astro:content";
+
+import Icon from "./Icon.astro";
+import Accordion from "./content/Accordion.astro";
+import AccordionItem from "./content/AccordionItem.astro";
+import AutoTypeTable from "./content/AutoTypeTable.astro";
+import Badge from "./content/Badge.astro";
+import Callout from "./content/Callout.astro";
+import Card from "./content/Card.astro";
+import CardGroup from "./content/CardGroup.astro";
+import CodeBlock from "./content/CodeBlock.astro";
+import CodeGroup from "./content/CodeGroup.astro";
+import ColorItem from "./content/ColorItem.astro";
+import ColorRoot from "./content/Color.astro";
+import ColorRow from "./content/ColorRow.astro";
+import Column from "./content/Column.astro";
+import Columns from "./content/Columns.astro";
+import Component from "./content/Component.astro";
+import Diff from "./content/Diff.astro";
+import Expandable from "./content/Expandable.astro";
+import FileTree from "./content/FileTree.astro";
+import Frame from "./content/Frame.astro";
+import GithubInfo from "./content/GithubInfo.astro";
+import Panel from "./content/Panel.astro";
+import Prompt from "./content/Prompt.astro";
+import Step from "./content/Step.astro";
+import Steps from "./content/Steps.astro";
+import Tab from "./content/Tab.astro";
+import Tabs from "./content/Tabs.astro";
+import Tile from "./content/Tile.astro";
+import Tooltip from "./content/Tooltip.astro";
+import TreeRoot from "./content/Tree.astro";
+import TreeFile from "./content/TreeFile.astro";
+import TreeFolder from "./content/TreeFolder.astro";
+import TypeTable from "./content/TypeTable.astro";
+import Visibility from "./content/Visibility.astro";
+import YouTube from "./content/YouTube.astro";
+
+interface Props {
+  /** Astro collection the entry lives in. Defaults to `"docs"`. */
+  collection?: string;
+  /** Extra MDX components merged over Blume's built-ins (overrides, islands). */
+  components?: Record<string, unknown>;
+  /** Content entry id — e.g. a `BlumeRoute.entryId` from `getBlumeCollection`. */
+  id: string;
+}
+
+const { collection = "docs", components: extra = {}, id } = Astro.props;
+
+const Color = Object.assign(ColorRoot, { Item: ColorItem, Row: ColorRow });
+const Tree = Object.assign(TreeRoot, { File: TreeFile, Folder: TreeFolder });
+
+const components = {
+  Accordion,
+  AccordionItem,
+  AutoTypeTable,
+  Badge,
+  Callout,
+  Card,
+  CardGroup,
+  CodeBlock,
+  CodeGroup,
+  Color,
+  Column,
+  Columns,
+  Component,
+  Diff,
+  Expandable,
+  FileTree,
+  Frame,
+  GithubInfo,
+  Icon,
+  Panel,
+  Prompt,
+  Step,
+  Steps,
+  Tab,
+  Tabs,
+  Tile,
+  Tooltip,
+  Tree,
+  TypeTable,
+  Visibility,
+  YouTube,
+  ...extra,
+};
+
+const entry = await getEntry(collection, id);
+const rendered = entry ? await render(entry) : null;
+const Content = rendered?.Content ?? null;
+---
+
+{Content && <Content components={components} />}

package/src/components/content/YouTube.astro

@@ -0,0 +1,35 @@
+---
+import { parseYouTubeId, youtubeEmbedUrl } from "./youtube.ts";
+
+interface Props {
+  /** A YouTube video id (e.g. `dQw4w9WgXcQ`). */
+  id?: string;
+  /** Start playback this many seconds in. */
+  start?: number;
+  /** Accessible title for the embedded player. */
+  title?: string;
+  /** A full YouTube URL to extract the id from, as an alternative to `id`. */
+  url?: string;
+}
+
+const { id, start, title = "YouTube video player", url } = Astro.props;
+
+const videoId = parseYouTubeId(id ?? url ?? "");
+const src = videoId ? youtubeEmbedUrl(videoId, { start }) : null;
+---
+
+{
+  src && (
+    <div class="not-prose my-6 aspect-video overflow-hidden rounded-blume border border-border bg-muted/30">
+      <iframe
+        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
+        allowfullscreen
+        class="h-full w-full"
+        loading="lazy"
+        referrerpolicy="strict-origin-when-cross-origin"
+        src={src}
+        title={title}
+      />
+    </div>
+  )
+}

package/src/components/content/youtube.ts

@@ -0,0 +1,46 @@
+/**
+ * Helpers for the `<YouTube>` content component. Kept in a sibling `.ts` (like
+ * `diff.ts`/`github-info.ts`) so the id parsing and embed-URL building are pure,
+ * unit-testable functions — the `.astro` file stays a thin presentational shell.
+ */
+
+// A YouTube video id is 11 characters of [A-Za-z0-9_-].
+const BARE_ID = /^[\w-]{11}$/u;
+
+// Pull the id out of any common YouTube URL: youtu.be/<id>, watch?v=<id>,
+// /embed/<id>, /shorts/<id>, /live/<id>.
+const URL_ID =
+  /(?:youtu\.be\/|\/embed\/|\/shorts\/|\/live\/|[?&]v=)(?<id>[\w-]{11})/u;
+
+/**
+ * Resolve a YouTube video id from either a bare id or a full URL. Returns `null`
+ * when nothing that looks like an id can be found, so the component can render
+ * nothing rather than a broken embed.
+ */
+export const parseYouTubeId = (input: string): string | null => {
+  const value = input.trim();
+  if (!value) {
+    return null;
+  }
+  if (BARE_ID.test(value)) {
+    return value;
+  }
+  return URL_ID.exec(value)?.groups?.id ?? null;
+};
+
+/**
+ * Build a privacy-enhanced (`youtube-nocookie.com`) embed URL, optionally
+ * starting at `start` seconds.
+ */
+export const youtubeEmbedUrl = (
+  id: string,
+  options: { start?: number } = {}
+): string => {
+  const base = `https://www.youtube-nocookie.com/embed/${id}`;
+  const { start } = options;
+  if (start && start > 0) {
+    const params = new URLSearchParams({ start: String(Math.floor(start)) });
+    return `${base}?${params.toString()}`;
+  }
+  return base;
+};

package/src/components/index.ts

@@ -2,9 +2,8 @@
  * Public component contracts.
  *
  * Prop types for built-in components are exported here so users can type their
- * overrides (`import type { CalloutProps } from "blume/components"`). Concrete
- * component types are added as components land; the override descriptor types
- * below are stable today.
+ * overrides (`import type { CalloutProps } from "blume/components"`), alongside
+ * the override descriptor types.
  */
 export type {
   ComponentOverride,
@@ -12,3 +11,4 @@ export type {
   IslandDescriptor,
 } from "../core/define-components.ts";
 export type { HydrationMode } from "../core/schema.ts";
+export type * from "./props.ts";

package/src/components/islands/ask-ai.tsx

@@ -25,6 +25,19 @@ const nextId = (): number => {
   return idCounter;
 };
 
+// The endpoint and page path both honor the deployment `base` so grounding works
+// under a non-root base path (the server matches base-less document routes).
+const ASK_ENDPOINT = `${import.meta.env.BASE_URL}api/ask`.replace("//", "/");
+
+/** The current route with the deployment base stripped, for page-context lookup. */
+const currentPath = (): string => {
+  const base = import.meta.env.BASE_URL;
+  const path = window.location.pathname;
+  return base.length > 1 && path.startsWith(base)
+    ? `/${path.slice(base.length)}`
+    : path;
+};
+
 const BUTTON_CLASS =
   "inline-flex h-9 cursor-pointer items-center gap-2 rounded-blume border border-border bg-muted px-2.5 text-muted-foreground text-sm hover:border-accent disabled:opacity-50";
 
@@ -72,28 +85,29 @@ const AskAI = ({ strings }: { strings?: UIStrings["ask"] }) => {
     setBusy(true);
 
     try {
-      const response = await fetch("/api/ask", {
+      const response = await fetch(ASK_ENDPOINT, {
         body: JSON.stringify({
           messages: history.map((m) => ({ content: m.content, role: m.role })),
+          page: { path: currentPath() },
         }),
         headers: { "content-type": "application/json" },
         method: "POST",
       });
-      const reader = response.body?.getReader();
+      // A 4xx/5xx still has a body; without this guard its error text would be
+      // decoded and shown as the assistant's answer instead of the error notice.
+      if (!(response.ok && response.body)) {
+        throw new Error(`Ask AI request failed (${response.status}).`);
+      }
+      const reader = response.body.getReader();
       const decoder = new TextDecoder();
-      if (reader) {
-        let done = false;
-        while (!done) {
-          // oxlint-disable-next-line no-await-in-loop -- sequential stream reads
-          const chunk = await reader.read();
-          ({ done } = chunk);
-          if (chunk.value) {
-            assistant.content += decoder.decode(chunk.value);
-            setMessages((current) => [
-              ...current.slice(0, -1),
-              { ...assistant },
-            ]);
-          }
+      let done = false;
+      while (!done) {
+        // oxlint-disable-next-line no-await-in-loop -- sequential stream reads
+        const chunk = await reader.read();
+        ({ done } = chunk);
+        if (chunk.value) {
+          assistant.content += decoder.decode(chunk.value);
+          setMessages((current) => [...current.slice(0, -1), { ...assistant }]);
         }
       }
     } catch {

package/src/components/islands/hooks.ts

@@ -0,0 +1,188 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+import type { BlumeClientData } from "../../core/data.ts";
+import type { SearchFn, SearchResult } from "../layout/search/types.ts";
+
+/**
+ * React hooks for Blume islands.
+ *
+ * Islands hydrate independently (there's no shared React root spanning them), so
+ * project data can't come through context. Instead the layout serializes a small
+ * snapshot into a `<script type="application/json" id="blume-client-data">` tag,
+ * and {@link useBlume}/{@link usePage} read it after mount. {@link useSearch} and
+ * {@link useAskAI} wrap the generated search client and the Ask AI endpoint.
+ *
+ * Import them from `blume/hooks`:
+ *
+ * ```tsx
+ * import { useBlume, usePage } from "blume/hooks";
+ * ```
+ */
+
+export type { BlumeClientData } from "../../core/data.ts";
+
+let cachedData: BlumeClientData | null = null;
+
+/** Read + parse the injected snapshot (memoized); null on the server. */
+const readClientData = (): BlumeClientData | null => {
+  if (cachedData) {
+    return cachedData;
+  }
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const element = document.querySelector("#blume-client-data");
+  if (!element?.textContent) {
+    return null;
+  }
+  try {
+    cachedData = JSON.parse(element.textContent) as BlumeClientData;
+    return cachedData;
+  } catch {
+    return null;
+  }
+};
+
+/**
+ * Read the injected snapshot after mount. `null` on the server and on the first
+ * client render (so hydration matches), then the data once mounted.
+ */
+const useClientData = (): BlumeClientData | null => {
+  const [data, setData] = useState<BlumeClientData | null>(null);
+  useEffect(() => setData(readClientData()), []);
+  return data;
+};
+
+/** Site config + navigation for the current page, or `null` before mount. */
+export const useBlume = (): Pick<
+  BlumeClientData,
+  "config" | "navigation"
+> | null => {
+  const data = useClientData();
+  return data ? { config: data.config, navigation: data.navigation } : null;
+};
+
+/** The current page's route + title, or `null` before mount. */
+export const usePage = (): BlumeClientData["page"] | null =>
+  useClientData()?.page ?? null;
+
+/** State + actions returned by {@link useSearch}. */
+export interface UseSearch {
+  loading: boolean;
+  results: SearchResult | null;
+  search: (
+    query: string,
+    options?: { locale?: string; section?: string }
+  ) => Promise<SearchResult>;
+}
+
+/**
+ * Query the site's configured search provider. The provider client is created
+ * lazily on the first search, so islands that never search ship no extra weight.
+ */
+export const useSearch = (): UseSearch => {
+  const [results, setResults] = useState<SearchResult | null>(null);
+  const [loading, setLoading] = useState(false);
+  const searchFn = useRef<SearchFn | null>(null);
+
+  const search = useCallback<UseSearch["search"]>(async (query, options) => {
+    if (!searchFn.current) {
+      const { createSearch } = await import("blume:search-client");
+      searchFn.current = await createSearch();
+    }
+    setLoading(true);
+    try {
+      const result = await searchFn.current(query, options);
+      setResults(result);
+      return result;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  return { loading, results, search };
+};
+
+/** A single Ask AI chat message. */
+export interface AskMessage {
+  content: string;
+  role: "assistant" | "user";
+}
+
+/** State + actions returned by {@link useAskAI}. */
+export interface UseAskAI {
+  ask: (question: string) => Promise<void>;
+  loading: boolean;
+  messages: AskMessage[];
+  reset: () => void;
+}
+
+const ASK_ENDPOINT = `${import.meta.env.BASE_URL}api/ask`.replace("//", "/");
+
+/** The current route with the deployment base stripped, for page grounding. */
+const currentPath = (): string => {
+  const base = import.meta.env.BASE_URL;
+  const path = window.location.pathname;
+  return base.length > 1 && path.startsWith(base)
+    ? `/${path.slice(base.length)}`
+    : path;
+};
+
+/**
+ * Stream answers from the Ask AI endpoint. Mirrors the built-in Ask AI island so
+ * a custom chat UI shares the same grounded, page-aware backend.
+ */
+export const useAskAI = (): UseAskAI => {
+  const [messages, setMessages] = useState<AskMessage[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  const ask = useCallback<UseAskAI["ask"]>(
+    async (question) => {
+      const trimmed = question.trim();
+      if (!trimmed || loading) {
+        return;
+      }
+      const history: AskMessage[] = [
+        ...messages,
+        { content: trimmed, role: "user" },
+      ];
+      const assistant: AskMessage = { content: "", role: "assistant" };
+      setMessages([...history, assistant]);
+      setLoading(true);
+      try {
+        const response = await fetch(ASK_ENDPOINT, {
+          body: JSON.stringify({
+            messages: history,
+            page: { path: currentPath() },
+          }),
+          headers: { "content-type": "application/json" },
+          method: "POST",
+        });
+        const reader = response.body?.getReader();
+        const decoder = new TextDecoder();
+        if (reader) {
+          let done = false;
+          while (!done) {
+            // oxlint-disable-next-line no-await-in-loop -- sequential stream reads
+            const chunk = await reader.read();
+            ({ done } = chunk);
+            if (chunk.value) {
+              assistant.content += decoder.decode(chunk.value);
+              setMessages((current) => [
+                ...current.slice(0, -1),
+                { ...assistant },
+              ]);
+            }
+          }
+        }
+      } finally {
+        setLoading(false);
+      }
+    },
+    [loading, messages]
+  );
+
+  const reset = useCallback(() => setMessages([]), []);
+
+  return { ask, loading, messages, reset };
+};