@symbiosis-lab/moss-api 0.7.11 → 0.10.0

package/dist/index.d.mts

@@ -1,12 +1,20 @@
 //#region src/types/plugin.d.ts
 /**
- * Base plugin types shared across all Moss plugins
+ * Base plugin types shared across all moss plugins
  */
 interface ProjectInfo {
   project_type: string;
   content_folders: string[];
   total_files: number;
   homepage_file?: string;
+  /**
+   * Root folder basename (e.g. "刘果"). Plugins that generate a folder home
+   * should name it self-named (`<folder_name>.md`) with a `home: true` marker
+   * to match moss's folder-home convention.
+   */
+  folder_name?: string;
+  site_name?: string;
+  lang?: string;
 }
 interface PluginManifest {
   name: string;
@@ -20,8 +28,292 @@ interface PluginManifest {
 }
 type PluginCategory = "generator" | "deployer" | "syndicator" | "enhancer" | "processor";
 //#endregion
+//#region src/types/messages.d.ts
+/**
+ * Plugin message types for communication with moss
+ */
+/**
+ * Messages that plugins can send to moss
+ */
+type PluginMessage = LogMessage | ProgressMessage | ErrorMessage | CompleteMessage;
+interface LogMessage {
+  type: "log";
+  level: "log" | "warn" | "error";
+  message: string;
+}
+interface ProgressMessage {
+  type: "progress";
+  phase: string;
+  current: number;
+  total: number;
+  message?: string;
+}
+interface ErrorMessage {
+  type: "error";
+  error: string;
+  context?: string;
+  fatal: boolean;
+}
+interface CompleteMessage {
+  type: "complete";
+  success: boolean;
+  error?: string;
+  result?: unknown;
+}
+//#endregion
+//#region src/utils/messaging.d.ts
+/**
+ * Set the message context for subsequent messages
+ * This is typically called automatically by the plugin runtime
+ */
+declare function setMessageContext(pluginName: string, hookName: string): void;
+/**
+ * Get the current message context
+ */
+declare function getMessageContext(): {
+  pluginName: string;
+  hookName: string;
+};
+/**
+ * Send a message to moss
+ *
+ * Log and progress messages use events (fire-and-forget) to avoid blocking IPC.
+ * Complete and error messages use commands (request-response) for acknowledgment.
+ */
+declare function sendMessage(message: PluginMessage): Promise<void>;
+/**
+ * Report progress to moss
+ */
+declare function reportProgress(phase: string, current: number, total: number, message?: string): Promise<void>;
+/**
+ * Report an error to moss
+ */
+declare function reportError(error: string, context?: string, fatal?: boolean): Promise<void>;
+/**
+ * Report completion to moss
+ * @param success - Whether the operation succeeded
+ * @param result - Optional result data
+ * @param error - Optional error message (only used when success is false)
+ */
+declare function reportComplete(success: boolean, result?: unknown, error?: string): Promise<void>;
+/**
+ * `PluginHook` mirrors the closed Rust enum in
+ * `src-tauri/src/plugins/types.rs`. The router (T1) cross-products
+ * `PluginHook × TriggerContext` to pick a UI surface for the task.
+ * Plugin authors pick the hook that matches what they're doing; they
+ * do NOT pick the surface (the router owns that).
+ */
+type PluginHook = "import" | "publish" | "deploy" | "syndicate" | "process" | "enhance";
+/**
+ * `TriggerContext` mirrors the closed Rust enum. Tells the router *why*
+ * the task was invoked so it can pick a surface that matches the user's
+ * focus context (onboarding cards → ActionPanel; background sync →
+ * Workspace).
+ */
+type TriggerContext = "onboarding_flow" | "settings_manual" | "background" | "manual_one";
+/**
+ * Escape kind for `awaiting()` calls. The string variants take a
+ * free-text affordance label after the colon, mirroring the dev harness
+ * dialect (e.g., `"resend:Resend email"`, `"recheck:Recheck DNS"`).
+ * Plain `"cancel"` carries no label.
+ */
+type EscapeSpec = "cancel" | `resend:${string}` | `recheck:${string}`;
+/**
+ * Which axis of the system an advisory is about. Mirrors the Rust
+ * `advisory::Scope` (externally-tagged unit enum → bare string).
+ */
+type AdvisoryScope = "File" | "Config" | "Environment" | "Remote" | "Account";
+/**
+ * How serious the plugin proposes an advisory is. moss CLAMPS this (R13): a
+ * `Blocking` proposal with no actionable affordance is demoted to a quiet
+ * `NeedsAction` hairline dot. Mirrors the Rust `advisory::Severity`.
+ */
+type AdvisorySeverity = "ShippedDegraded" | "NeedsAction" | "Blocking";
+/**
+ * A closed set of in-app operations an `AdvisoryAction.InApp` can request.
+ * Mirrors the Rust `advisory::AppOp`.
+ */
+type AdvisoryAppOp = "MoveFile" | "OpenBilling" | "SignIn" | "RecheckDns";
+/**
+ * The recovery affordance for an advisory, expressed as data — mirrors the
+ * Rust `advisory::Action` (externally-tagged: `"None"` for the unit variant,
+ * `{ Variant: {...} }` for data variants). `Action !== "None"` is the gavel's
+ * deciding input for whether a `Blocking` proposal may pop the panel.
+ */
+type AdvisoryAction = "None" | {
+  Command: {
+    run: string;
+    label: string;
+  };
+} | {
+  InApp: {
+    op: AdvisoryAppOp;
+    args: unknown;
+    label: string;
+  };
+} | {
+  Link: {
+    href: string;
+    label: string;
+  };
+};
+/**
+ * A plugin's PROPOSED advisory (pre-clamp). Mirrors the Rust
+ * `plugins::types::PluginAdvisory` wire shape exactly so it deserializes
+ * directly into `PluginTaskLifecycle::Succeeded/Failed { advisories }`. moss
+ * is the only constructor of a final `Advisory` — a plugin can never hand moss
+ * one (R13).
+ */
+interface AdvisoryProposal {
+  /** Which axis of the system this advisory is about. */
+  scope: AdvisoryScope;
+  /** The severity the plugin REQUESTS. moss clamps it (R13). */
+  severity: AdvisorySeverity;
+  /** The item this is about — usually a filename. `null` for build-wide. */
+  item: string | null;
+  /** What happened (free text). */
+  what: string;
+  /** The recovery affordance the plugin proposes. */
+  action: AdvisoryAction;
+}
+interface StartTaskOptions {
+  /**
+   * Hook the task belongs to. Defaults to "import" — the most common
+   * onboarding case. Plugins should pass an explicit hook for non-import
+   * work (e.g., a syndicator passes "syndicate").
+   */
+  hook?: PluginHook;
+  /**
+   * Trigger context. Defaults to "background" — the safest fallback
+   * because Background routes to Workspace+Ambient, the quietest surface.
+   * Plugins running inside the onboarding flow should pass
+   * "onboarding_flow" explicitly so they reach the ActionPanel hairline.
+   */
+  trigger?: TriggerContext;
+  /**
+   * Hint to the router that this task will emit `progress()` updates
+   * with fractions. Routers and renderers MAY use this to choose between
+   * "fills" vs "pulses" visualizations. Defaults to true.
+   */
+  hasProgress?: boolean;
+  /**
+   * Whether the user can cancel this task from the UI. Cancellation
+   * plumbing lands in a later ADR phase; the flag is recorded today so
+   * renderers can show / hide a cancel affordance.
+   */
+  cancellable?: boolean;
+  /**
+   * Plugin-local job id referencing `contributes.jobs[id]` in the plugin's
+   * manifest (Step 3 Phase 5, §8 + R13). When set, moss looks up the declared
+   * descriptor (a past-tense `verb` + an amount `noun`), normalizes the verb
+   * (`Verb::normalized` — moss owns capitalization/length/glyphs), and on a
+   * `succeeded(receipt, count)` stamps its OWN typed `Verb` + `Amount { count,
+   * noun }` on the Job — rendering "Syndicated · N posts" from moss's value
+   * objects, never the plugin's pre-formatted `receipt` string. Omit it for
+   * free-text-receipt tasks (the legacy path, byte-identical).
+   */
+  job?: string;
+}
+/**
+ * Lifecycle handle returned by `startTask()`. Calls are fire-and-await:
+ * each method returns a promise that resolves once the Rust side has
+ * applied the transition to the PanelTask registry. Terminal calls
+ * (`succeeded`, `failed`, `cancelled`) remove the task from the registry's
+ * tracking store; calling any further method on the same handle will
+ * reject with "unknown plugin task id".
+ *
+ * The state machine matches ADR-015 § Layer 2:
+ *
+ *   Running ↔ Awaiting → Succeeded | Failed | Cancelled
+ *
+ * `progress()` after `awaiting()` implicitly transitions back to Running
+ * (no explicit `resumed()`).
+ */
+interface TaskHandle {
+  /**
+   * In-process task id minted by the Rust registry on `Started`.
+   * Exposed for log correlation and tests.
+   *
+   * Rust-side this is `u64`; specta types `u64` as `string` because
+   * JS numbers lose precision above 2^53. The handle carries the
+   * exact string through subsequent transitions so no precision is
+   * lost in the round-trip.
+   */
+  readonly id: string;
+  /** Push a progress update. `fraction` in [0,1] if known, else undefined for indeterminate. */
+  progress(fraction?: number, message?: string): Promise<void>;
+  /**
+   * Pause for an out-of-band user action. `directive` describes what
+   * the user needs to do ("click the link in your email"); `venue`
+   * names where ("your email") — both feed the Awaiting renderer's
+   * "Waiting for you to [directive] in [venue]" copy.
+   *
+   * `escape` defaults to "cancel". For non-cancel escapes, pass
+   * "resend:<label>" or "recheck:<label>".
+   */
+  awaiting(directive: string, venue: string, escape?: EscapeSpec): Promise<void>;
+  /**
+   * PROPOSE an advisory on this task (Step 3 Phase 5, §8 + R13). Accumulates
+   * the proposal on the handle; it is flushed into the next terminal call
+   * (`succeeded`/`failed`) as `advisories: PluginAdvisory[]`. moss holds the
+   * severity gavel server-side: a `Blocking` proposal with no actionable
+   * `action` is clamped to a quiet `NeedsAction` dot; an actionable `Blocking`
+   * on a `succeeded()` flips the run to `Failed` (invariant #1 — the smart
+   * constructor decides, not the plugin).
+   *
+   * `advise()` does NOT emit on its own; advisories ride the terminal IPC so
+   * moss applies them atomically with the success/failure transition. Calling
+   * `advise()` after a terminal call has no effect — the handle is spent (the
+   * terminal methods set a spent flag and `advise()` no-ops once spent).
+   */
+  advise(advisory: AdvisoryProposal): Promise<void>;
+  /**
+   * Terminal: success.
+   *
+   * @param receipt Optional human-readable receipt (the legacy free-text path).
+   *   IGNORED for the verb/amount when the task declared a `job` descriptor —
+   *   moss renders the receipt from its OWN normalized verb + amount instead.
+   * @param amount Optional success COUNT. Only meaningful when `startTask` was
+   *   given a `job` id: moss pairs this count with the descriptor's `noun` to
+   *   stamp `Amount { count, noun }` and renders "Syndicated · N posts" from its
+   *   value objects.
+   */
+  succeeded(receipt?: string, amount?: number): Promise<void>;
+  /**
+   * Terminal: failure. `recoverable=false` (default) also fires the
+   * toast subscriber (ADR-015 § "Plugin-originated failure toasts").
+   */
+  failed(error: string, recoverable?: boolean): Promise<void>;
+  /** Terminal: explicit user cancellation. */
+  cancelled(): Promise<void>;
+}
+/**
+ * Start a plugin task. Returns a `TaskHandle` whose methods drive the
+ * lifecycle (progress → awaiting → succeeded/failed/cancelled).
+ *
+ * The hook + trigger pair flows into the Rust-side `route_plugin_task`
+ * router, which picks `(TaskScope, TaskKind, TaskTone)` — i.e., which
+ * UI renderer (Ambient hairline / Inline badge / Narrated titlebar /
+ * Awaiting pulse) surfaces the task. Plugin authors do NOT pick the
+ * surface; they just describe what they're doing and why.
+ *
+ * Preferred over `reportProgress()` for new code. The legacy API stays
+ * supported until ADR-015 Phase 3 sweeps all 151 call sites.
+ *
+ * @example
+ * const task = await startTask("Importing 42 articles", {
+ *   hook: "import",
+ *   trigger: "onboarding_flow",
+ * });
+ * for (let i = 0; i < articles.length; i++) {
+ *   await task.progress(i / articles.length, `Article ${i + 1}/${articles.length}`);
+ *   await importOne(articles[i]);
+ * }
+ * await task.succeeded(`Imported ${articles.length} articles`);
+ */
+declare function startTask(label: string, options?: StartTaskOptions): Promise<TaskHandle>;
+//#endregion
 //#region src/types/context.d.ts
-
 /**
  * Base context shared by all hooks
  *
@@ -35,8 +327,15 @@ interface BaseContext {
 }
 /**
  * Context for before_build hook (process capability)
+ *
+ * `trigger` is stamped by moss (ADR-015): the plugin reads it to declare task
+ * intent via `startTask`, it does NOT guess it. Onboarding card → "onboarding_flow"
+ * (drives the ambient hairline); every build/preview rebuild → "background".
+ * Optional for backward compatibility; absent ⇒ treat as "background".
  */
-interface BeforeBuildContext extends BaseContext {}
+interface ProcessContext extends BaseContext {
+  trigger?: TriggerContext;
+}
 /**
  * A node in the universal Page Tree.
  *
@@ -68,10 +367,8 @@ interface PageNode {
   nav: boolean;
   /** Navigation ordering (lower = first) */
   nav_weight?: number;
-  /** Don't generate page at all */
+  /** Whether this page is a draft — rendered and published at its direct URL but hidden from listings, feeds, and navigation. */
   draft: boolean;
-  /** Generate page but hide from parent's child list */
-  unlisted: boolean;
   /** Recursively list all nested content */
   flatten: boolean;
   /** How children display: "list", "grid", or "sidebar" */
@@ -84,7 +381,7 @@ interface PageNode {
 /**
  * Context for on_build hook (generator plugins)
  */
-interface OnBuildContext extends BaseContext {
+interface GenerateContext extends BaseContext {
   source_files: SourceFiles;
   /** Resolved Page Tree — universal content model for all generators */
   page_tree?: PageNode;
@@ -92,13 +389,45 @@ interface OnBuildContext extends BaseContext {
 /**
  * Context for on_deploy hook (deployer plugins)
  */
-interface OnDeployContext extends BaseContext {
+interface DeployContext extends BaseContext {
   site_files: string[];
+  /** Custom domain from .moss/config.toml [deployment] section (if configured) */
+  domain?: string;
+}
+/**
+ * Context for configure_domain hook (custom domain setup on deploy platform)
+ *
+ * Called after DNS records are configured via moss-oracle. Allows deploy plugins
+ * to perform platform-specific domain setup (e.g., GitHub Pages CNAME configuration).
+ *
+ * This is NOT a separate capability - it's an optional hook on Deploy-capable plugins.
+ *
+ * ## Idempotency Contract
+ *
+ * The domain orchestrator calls this hook at multiple lifecycle points:
+ * 1. After DNS records are configured (site may not be live yet)
+ * 2. After the site is verified live via HTTP 200
+ *
+ * **Plugins MUST implement this hook as idempotent.** The plugin should:
+ * - Check current platform state
+ * - Do only the next needed step
+ * - Return success as a no-op if already fully configured
+ *
+ * Example (GitHub Pages):
+ * - Call 1: Sets CNAME file via API
+ * - Call 2: Verifies CNAME is set, enforces HTTPS via API
+ * - Call 3+: Both already done, returns success without changes
+ */
+interface ConfigureDomainContext extends BaseContext {
+  /** The custom domain being configured (e.g., "example.com") */
+  domain: string;
+  /** Deployment information from the last deploy */
+  deployment: DeploymentInfo;
 }
 /**
  * Context for after_deploy hook (syndicator plugins)
  */
-interface AfterDeployContext extends BaseContext {
+interface SyndicateContext extends BaseContext {
   site_files: string[];
   articles: ArticleInfo[];
   deployment?: DeploymentInfo;
@@ -154,7 +483,7 @@ interface DnsRecord {
  * DNS configuration provided by deploy plugins
  *
  * Plugins are responsible for generating the appropriate DNS records
- * for their platform. Moss just passes these through to DNS configuration.
+ * for their platform. moss just passes these through to DNS configuration.
  */
 interface DnsTarget {
   /** List of DNS records to configure */
@@ -194,37 +523,66 @@ interface HookResult {
   deployment?: DeploymentInfo;
 }
 //#endregion
-//#region src/types/messages.d.ts
+//#region src/types/enhance.d.ts
 /**
- * Plugin message types for communication with Moss
- */
-/**
- * Messages that plugins can send to Moss
+ * Types for the content slots system.
+ *
+ * Plugins declare what content to inject and where using these types.
+ * Rust handles insertion during template rendering.
  */
-type PluginMessage = LogMessage | ProgressMessage | ErrorMessage | CompleteMessage;
-interface LogMessage {
-  type: "log";
-  level: "log" | "warn" | "error";
-  message: string;
+/** Context passed to a plugin's `enhance()` method. */
+interface EnhanceContext {
+  project_path: string;
+  moss_dir: string;
+  output_dir: string;
+  config: Record<string, unknown>;
+  project_info: {
+    site_name: string;
+    lang: string;
+  };
+  article_map: Record<string, unknown>;
 }
-interface ProgressMessage {
-  type: "progress";
-  phase: string;
-  current: number;
-  total: number;
-  message?: string;
+/** Content declaration for a single slot. */
+type EnhanceContent = {
+  type: "static";
+  html: string;
+} | {
+  type: "per-page";
+  pages: Record<string, string>;
+};
+/** Result returned from a plugin's `enhance()` call. */
+interface EnhanceResult {
+  success: boolean;
+  slots: Record<string, EnhanceContent>;
 }
-interface ErrorMessage {
-  type: "error";
-  error: string;
-  context?: string;
-  fatal: boolean;
+//#endregion
+//#region src/types/social.d.ts
+/** One comment in the .moss/data/social/*.json shared standard.
+ *  See moss/docs/architecture/social-data-standard.md. */
+interface SocialComment {
+  id: string;
+  source: string;
+  content: string;
+  createdAt: string;
+  author: {
+    displayName: string;
+    url?: string;
+  };
+  replyToId?: string;
+  /**
+   * Moderation state. Absent or "active" = visible; anything else is filtered
+   * at read time. Well-known values: "active" | "removed" | "archived" |
+   * "banned" | "collapsed". The Rust side treats this as an open string so
+   * future states do not require a client update.
+   */
+  state?: string;
 }
-interface CompleteMessage {
-  type: "complete";
-  success: boolean;
-  error?: string;
-  result?: unknown;
+interface SocialArticleData {
+  comments: SocialComment[];
+}
+interface SocialDataFile {
+  schemaVersion: string;
+  articles: Record<string, SocialArticleData>;
 }
 //#endregion
 //#region src/utils/tauri.d.ts
@@ -251,81 +609,37 @@ declare function getTauriCore(): TauriCore;
  */
 declare function isTauriAvailable(): boolean;
 //#endregion
-//#region src/utils/messaging.d.ts
-/**
- * Set the message context for subsequent messages
- * This is typically called automatically by the plugin runtime
- */
-declare function setMessageContext(pluginName: string, hookName: string): void;
-/**
- * Get the current message context
- */
-declare function getMessageContext(): {
-  pluginName: string;
-  hookName: string;
-};
-/**
- * Send a message to Moss
- *
- * Log and progress messages use events (fire-and-forget) to avoid blocking IPC.
- * Complete and error messages use commands (request-response) for acknowledgment.
- */
-declare function sendMessage(message: PluginMessage): Promise<void>;
-/**
- * Report progress to Moss
- */
-declare function reportProgress(phase: string, current: number, total: number, message?: string): Promise<void>;
-/**
- * Report an error to Moss
- */
-declare function reportError(error: string, context?: string, fatal?: boolean): Promise<void>;
-/**
- * Report completion to Moss
- * @param success - Whether the operation succeeded
- * @param result - Optional result data
- * @param error - Optional error message (only used when success is false)
- */
-declare function reportComplete(success: boolean, result?: unknown, error?: string): Promise<void>;
-//#endregion
-//#region src/utils/logger.d.ts
+//#region src/utils/env.d.ts
 /**
- * Logging utilities for plugins
- *
- * @deprecated All functions in this module are deprecated.
- * Use console.log/warn/error directly instead.
+ * Plugin-side env-var access.
  *
- * The plugin runtime now auto-forwards all console.* calls to Rust,
- * eliminating the need for these async wrappers. Using console.* directly
- * is simpler and has no async overhead.
+ * Plugins run inside a webview (no Node `process.env`), so reading host
+ * environment variables requires a Rust→TS bridge. The
+ * `get_plugin_env_var` Tauri command in `src-tauri/src/plugins/runtime.rs`
+ * enforces a server-side allow-list — plugins cannot read arbitrary
+ * environment variables, only the ones moss has whitelisted for test /
+ * harness use.
  *
- * Example migration:
- *   // Before
- *   await log("Starting deployment...");
+ * Currently allow-listed (see runtime.rs `ALLOWED` constant):
+ * - `MOSS_MATTERS_TEST_PROFILE` — bypasses Matters auth and switches to
+ *   public-fetch mode for the named profile (T8a e2e harness).
+ * - `MOSS_MATTERS_DOMAIN` — overrides the Matters domain (e.g. "matters.icu")
+ *   so moss-claude.sh can target the test env without pre-seeding config.json.
  *
- *   // After
- *   console.log("Starting deployment...");
+ * New entries require an explicit Rust-side edit + code review.
  */
 /**
- * Log an informational message
+ * Read a host environment variable into the plugin webview.
  *
- * @deprecated Use console.log() directly instead.
- * Plugin runtime auto-forwards all console.* calls to Rust.
- */
-declare function log(message: string): Promise<void>;
-/**
- * Log a warning message
- *
- * @deprecated Use console.warn() directly instead.
- * Plugin runtime auto-forwards all console.* calls to Rust.
- */
-declare function warn(message: string): Promise<void>;
-/**
- * Log an error message
+ * Returns `undefined` if:
+ * - Tauri is unavailable (running outside the moss webview),
+ * - the variable is not in the server-side allow-list, or
+ * - the variable is not set in the host process.
  *
- * @deprecated Use console.error() directly instead.
- * Plugin runtime auto-forwards all console.* calls to Rust.
+ * Plugins should treat the return value as best-effort: a missing value
+ * is the production default, not an error.
  */
-declare function error(message: string): Promise<void>;
+declare function getPluginEnvVar(name: string): Promise<string | undefined>;
 //#endregion
 //#region src/utils/browser.d.ts
 /**
@@ -353,7 +667,7 @@ interface BrowserHandle {
   closed: Promise<BrowserCloseReason>;
 }
 /**
- * Open a URL in the plugin browser window
+ * Open a URL in the action panel
  *
  * Returns a BrowserHandle that can be used to detect when the window is closed.
  *
@@ -377,9 +691,18 @@ interface BrowserHandle {
  */
 declare function openBrowser(url: string): Promise<BrowserHandle>;
 /**
- * Close the plugin browser window
+ * Close the action panel
  */
 declare function closeBrowser(): Promise<void>;
+/**
+ * Ask the app shell to restore the editor in the action panel after a login
+ * flow cancel or failure. Clears the onboarding latch and re-mounts the
+ * editor (empty-folder onboarding cards) in the action panel slot.
+ *
+ * Call this after `promptLogin()` returns false on an import (binding /
+ * prompt_login) path so the user isn't left with an empty action panel.
+ */
+declare function returnToEditor(): Promise<void>;
 /**
  * Open a URL in the system's default browser
  *
@@ -395,42 +718,93 @@ declare function closeBrowser(): Promise<void>;
  */
 declare function openSystemBrowser(url: string): Promise<void>;
 /**
- * Open the plugin browser with dynamic HTML content
+ * Open the action panel with dynamic HTML content
  *
  * Automatically injects a bridge script that exposes `window.mossApi` with:
- * - `submit(data)` - emits `moss:browser-form-submit` event
- * - `cancel()` - emits `moss:browser-form-cancel` event
  * - `close()` - closes the browser panel
- * - `emit(name, payload)` - escape hatch for custom events
+ * - `emit(name, payload)` - emits custom events for plugin-specific communication
  *
  * Uses a custom protocol (moss-plugin://) to serve HTML content
  * without requiring the `webview-data-url` Cargo feature.
  *
+ * **Manual lifecycle control:**
+ * After calling this function, the browser panel remains open until you explicitly
+ * call `closeBrowser()` or the user closes it. Use `listen()` to handle custom
+ * events emitted from the HTML.
+ *
  * @param html - Raw HTML content to display
  * @example
  * ```typescript
+ * import { openBrowserWithHtml, closeBrowser, listen } from "@symbiosis-lab/moss-api";
+ *
+ * // Open browser with custom HTML
  * await openBrowserWithHtml(`
  *   <!DOCTYPE html>
  *   <html>
  *     <head><title>My Form</title></head>
  *     <body>
- *       <form onsubmit="event.preventDefault(); window.mossApi.submit({ name: 'Alice' })">
- *         <input name="name" />
+ *       <form id="myForm">
+ *         <input id="nameInput" name="name" />
  *         <button type="submit">Submit</button>
- *         <button type="button" onclick="window.mossApi.cancel()">Cancel</button>
+ *         <button type="button" onclick="window.mossApi.close()">Cancel</button>
  *       </form>
+ *       <script>
+ *         document.getElementById('myForm').addEventListener('submit', (e) => {
+ *           e.preventDefault();
+ *           window.mossApi.emit('my-plugin:form-submit', {
+ *             name: document.getElementById('nameInput').value
+ *           });
+ *         });
+ *       </script>
  *     </body>
  *   </html>
  * `);
+ *
+ * // Listen for custom event from HTML
+ * const unlisten = await listen('my-plugin:form-submit', (event) => {
+ *   console.log('User submitted:', event.payload);
+ *   closeBrowser(); // Explicitly close when done
+ * });
  * ```
  */
 declare function openBrowserWithHtml(html: string): Promise<void>;
 /**
  * Show an HTML form in the browser panel and wait for the user to submit or cancel.
  *
- * The HTML should use `window.mossApi.submit(data)` to submit form data
- * and `window.mossApi.cancel()` to cancel. The bridge script is automatically
- * injected by `openBrowserWithHtml`.
+ * @deprecated This function couples form lifecycle to moss internals through hidden event listeners.
+ * Use `openBrowserWithHtml()` + manual `closeBrowser()` instead for explicit control.
+ *
+ * **Migration guide:**
+ * ```typescript
+ * // OLD (deprecated):
+ * const result = await showBrowserForm<LoginData>(html);
+ * if (result) {
+ *   console.log("Submitted:", result);
+ * }
+ *
+ * // NEW (recommended):
+ * await openBrowserWithHtml(html);
+ *
+ * // Listen for custom event
+ * const unlisten = await listen<LoginData>("my-plugin:submit", (event) => {
+ *   console.log("Submitted:", event.payload);
+ *   closeBrowser();
+ * });
+ *
+ * // In your HTML:
+ * // <button onclick="window.mossApi.emit('my-plugin:submit', { username: '...' })">Submit</button>
+ * // <button onclick="window.mossApi.close()">Cancel</button>
+ * ```
+ *
+ * **Why migrate:**
+ * - Explicit browser lifecycle control (no magic auto-close)
+ * - No hidden event listeners (`moss:browser-form-submit`, `moss:browser-form-cancel`)
+ * - Simpler mental model: open, use, close
+ * - Matches modern plugin patterns (see Matters plugin)
+ *
+ * Note: This deprecated function still listens for `moss:browser-form-submit` and
+ * `moss:browser-form-cancel` events for backward compatibility. New code should use
+ * `window.mossApi.emit('your-event', data)` and `window.mossApi.close()` instead.
  *
  * Returns the submitted data, or `null` if the user cancelled or the timeout expired.
  * The browser is automatically closed in all cases.
@@ -438,6 +812,7 @@ declare function openBrowserWithHtml(html: string): Promise<void>;
  * @param html - Raw HTML content with a form
  * @param options - Optional configuration
  * @param options.timeoutMs - Maximum time to wait (default: 300000ms / 5 minutes)
+ * @param options.closeDelayMs - Optional delay before closing browser (default: 0ms / immediate)
  * @returns The submitted form data, or null on cancel/timeout
  *
  * @example
@@ -453,12 +828,12 @@ declare function openBrowserWithHtml(html: string): Promise<void>;
  *         <input id="user" placeholder="Username" />
  *         <input id="pass" type="password" placeholder="Password" />
  *         <button type="submit">Login</button>
- *         <button type="button" onclick="window.mossApi.cancel()">Cancel</button>
+ *         <button type="button" onclick="window.mossApi.close()">Cancel</button>
  *       </form>
  *       <script>
  *         document.getElementById('login').addEventListener('submit', (e) => {
  *           e.preventDefault();
- *           window.mossApi.submit({
+ *           window.mossApi.emit('moss:browser-form-submit', {
  *             username: document.getElementById('user').value,
  *             password: document.getElementById('pass').value,
  *           });
@@ -477,11 +852,12 @@ declare function openBrowserWithHtml(html: string): Promise<void>;
  */
 declare function showBrowserForm<T>(html: string, options?: {
   timeoutMs?: number;
+  closeDelayMs?: number;
 }): Promise<T | null>;
 //#endregion
 //#region src/utils/filesystem.d.ts
 /**
- * File system operations for Moss plugins
+ * File system operations for moss plugins
  *
  * These functions provide access to project files (user content).
  * Project path is auto-detected from the runtime context.
@@ -545,6 +921,21 @@ declare function writeFile(relativePath: string, content: string): Promise<void>
  * ```
  */
 declare function listFiles(): Promise<string[]>;
+/** A project file with home-file annotation from Rust's detect_home_file_in_folder */
+interface ProjectFileEntry {
+  path: string;
+  is_home: boolean;
+}
+/**
+ * List all project files with home-file annotations
+ *
+ * Each file is annotated with `is_home: true` if it's the detected home file
+ * for its containing folder (index.md, README.md, self-named folder note, etc.).
+ * Detection uses the same logic as the built-in generator.
+ *
+ * @returns Array of file entries with is_home annotations
+ */
+declare function listProjectTree(): Promise<ProjectFileEntry[]>;
 /**
  * Check if a file exists in the project directory
  *
@@ -580,10 +971,80 @@ declare function fileExists(relativePath: string): Promise<boolean>;
  * ```
  */
 declare function createSymlink(targetPath: string, linkPath: string): Promise<void>;
+/**
+ * Read a file from the compiled site directory (.moss/site/)
+ *
+ * Returns base64-encoded content. Used by deploy plugins to read
+ * site files without direct filesystem access.
+ *
+ * @param relativePath - Path relative to the site directory (e.g., "index.html")
+ * @returns Base64-encoded file content
+ * @throws Error if file cannot be read
+ *
+ * @example
+ * ```typescript
+ * const base64Content = await readSiteFile("index.html");
+ * const base64Image = await readSiteFile("assets/logo.png");
+ * ```
+ */
+declare function readSiteFile(relativePath: string): Promise<string>;
+/**
+ * Read a file from the project root as base64
+ *
+ * Returns base64-encoded content. Used by deploy plugins for
+ * source file backup operations.
+ *
+ * @param relativePath - Path relative to the project root
+ * @returns Base64-encoded file content
+ * @throws Error if file cannot be read
+ *
+ * @example
+ * ```typescript
+ * const base64Content = await readProjectFileBase64("posts/article.md");
+ * ```
+ */
+declare function readProjectFileBase64(relativePath: string): Promise<string>;
+/**
+ * List source files in the project directory
+ *
+ * Returns relative paths of non-hidden files, excluding build artifacts
+ * (.moss/, .git/, node_modules/). Used by deploy plugins for source backup.
+ *
+ * @returns Array of relative file paths
+ * @throws Error if listing fails
+ *
+ * @example
+ * ```typescript
+ * const sourceFiles = await listSourceFiles();
+ * // ["index.md", "posts/hello.md", "assets/logo.png"]
+ * ```
+ */
+declare function listSourceFiles(): Promise<string[]>;
+/**
+ * List social data source names from .moss/data/social/*.json
+ *
+ * Returns file stems (without .json extension) for all JSON files
+ * in the project's .moss/data/social/ directory. Returns empty array
+ * if directory doesn't exist.
+ *
+ * @returns Array of source names (e.g., ["comment", "douban", "matters"])
+ */
+declare function listSocialFiles(): Promise<string[]>;
+/** File path and size from the compiled site directory */
+interface SiteFileInfo {
+  path: string;
+  size: number;
+}
+/**
+ * List all files in the compiled site directory with their sizes
+ *
+ * @returns Array of file info objects with path and size in bytes
+ */
+declare function listSiteFilesWithSizes(): Promise<SiteFileInfo[]>;
 //#endregion
 //#region src/utils/plugin-storage.d.ts
 /**
- * Plugin storage API for Moss plugins
+ * Plugin storage API for moss plugins
  *
  * Provides access to a plugin's private storage directory at:
  * .moss/plugins/{plugin-name}/
@@ -668,7 +1129,7 @@ declare function pluginFileExists(relativePath: string): Promise<boolean>;
 //#endregion
 //#region src/utils/http.d.ts
 /**
- * HTTP operations for Moss plugins
+ * HTTP operations for moss plugins
  *
  * These functions provide HTTP capabilities that bypass browser CORS
  * restrictions by using Rust's HTTP client under the hood.
@@ -770,6 +1231,14 @@ interface PostOptions {
  * }
  * ```
  */
+/**
+ * Convert an HTML fragment to Markdown via moss's bundled `htmd` converter —
+ * the same converter the rest of the app uses. Plugins call this instead of
+ * shipping their own HTML→Markdown pass, so output (notably hard breaks, which
+ * htmd renders as two trailing spaces rather than a lone backslash) is
+ * consistent app-wide. Returns the input HTML unchanged if conversion fails.
+ */
+declare function htmlToMarkdown(html: string): Promise<string>;
 declare function httpPost(url: string, body: Record<string, unknown>, options?: PostOptions): Promise<FetchResult>;
 /**
  * Options for HTTP GET requests
@@ -804,6 +1273,65 @@ interface GetOptions {
  * ```
  */
 declare function httpGet(url: string, options?: GetOptions): Promise<FetchResult>;
+/**
+ * One ordered text field in a multipart/form-data POST.
+ *
+ * Order is preserved because the GraphQL multipart request spec requires
+ * `operations` before `map` before the file parts.
+ */
+interface MultipartTextField {
+  /** Form field name (e.g. "operations", "map"). */
+  name: string;
+  /** Field value (e.g. the JSON-encoded GraphQL operation). */
+  value: string;
+}
+/**
+ * One file part in a multipart/form-data POST. Bytes are passed base64-encoded —
+ * e.g. straight from `readSiteFile`, which already returns base64.
+ */
+interface MultipartFilePart {
+  /** Form field name for this file (e.g. "0" per the GraphQL multipart spec). */
+  field: string;
+  /** File name reported in the part's Content-Disposition. */
+  filename: string;
+  /** MIME type for the part's Content-Type header. */
+  contentType: string;
+  /** File contents, base64-encoded. */
+  contentBase64: string;
+}
+/**
+ * Options for a multipart POST request.
+ */
+interface MultipartPostOptions {
+  /** Timeout in milliseconds (default: 30000) */
+  timeoutMs?: number;
+  /** Additional headers (Content-Type is set automatically and cannot be overridden) */
+  headers?: Record<string, string>;
+}
+/**
+ * Perform an HTTP POST with a `multipart/form-data` body.
+ *
+ * Unlike {@link httpPost} (JSON-only), this sends ordered text fields plus
+ * binary file parts — enabling uploads to GraphQL `singleFileUpload`-style
+ * endpoints. File bytes are passed base64-encoded (so they survive the IPC
+ * boundary and can come directly from {@link readSiteFile}); moss builds the
+ * multipart body, generates the boundary, and sets the Content-Type.
+ *
+ * @example
+ * ```typescript
+ * const res = await httpPostMultipart(endpoint, {
+ *   textFields: [
+ *     { name: "operations", value: JSON.stringify({ query, variables }) },
+ *     { name: "map", value: JSON.stringify({ "0": ["variables.input.file"] }) },
+ *   ],
+ *   files: [{ field: "0", filename: "photo.jpg", contentType: "image/jpeg", contentBase64 }],
+ * }, { headers: { "x-access-token": token } });
+ * ```
+ */
+declare function httpPostMultipart(url: string, parts: {
+  textFields?: MultipartTextField[];
+  files?: MultipartFilePart[];
+}, options?: MultipartPostOptions): Promise<FetchResult>;
 /**
  * Download a URL and save directly to disk
  *
@@ -834,7 +1362,7 @@ declare function downloadAsset(url: string, targetDir: string, options?: Downloa
 //#endregion
 //#region src/utils/binary.d.ts
 /**
- * Binary execution for Moss plugins
+ * Binary execution for moss plugins
  *
  * Allows plugins to execute external binaries (git, npm, etc.)
  * in a controlled environment.
@@ -856,6 +1384,15 @@ interface ExecuteOptions {
   env?: Record<string, string>;
   /** Data to pass to stdin (useful for commands like `git credential fill`) */
   stdin?: string;
+  /** Working directory relative to project root (default: project root itself) */
+  workingDir?: string;
+  /**
+   * Callback for real-time stderr output. When provided, stderr lines are
+   * streamed from the Rust backend via Tauri events as they are produced.
+   * Useful for long-running processes like `git push` where you want to
+   * show progress to the user.
+   */
+  onStderr?: (line: string) => void;
 }
 /**
  * Result from binary execution
@@ -910,7 +1447,7 @@ declare function executeBinary(options: ExecuteOptions): Promise<ExecuteResult>;
 //#endregion
 //#region src/utils/platform.d.ts
 /**
- * Platform detection utilities for Moss plugins
+ * Platform detection utilities for moss plugins
  *
  * Detects the current operating system and architecture to enable
  * platform-specific binary downloads and operations.
@@ -966,143 +1503,110 @@ declare function getPlatformInfo(): Promise<PlatformInfo>;
  */
 declare function clearPlatformCache(): void;
 //#endregion
-//#region src/utils/archive.d.ts
-/**
- * Archive extraction utilities for Moss plugins
- *
- * Provides functions to extract .tar.gz and .zip archives using
- * system commands (tar, unzip, PowerShell).
- */
-/**
- * Supported archive formats
- */
-type ArchiveFormat = "tar.gz" | "zip";
-/**
- * Options for archive extraction
- */
-interface ExtractOptions {
-  /** Path to the archive file (absolute) */
-  archivePath: string;
-  /** Directory to extract to (absolute) */
-  destDir: string;
-  /** Archive format (auto-detected from extension if not provided) */
-  format?: ArchiveFormat;
-  /** Timeout in milliseconds (default: 60000) */
-  timeoutMs?: number;
-}
-/**
- * Result of archive extraction
- */
-interface ExtractResult {
-  /** Whether extraction succeeded */
-  success: boolean;
-  /** Error message if extraction failed */
-  error?: string;
-}
+//#region src/utils/binary-resolver.d.ts
 /**
- * Extract an archive to a destination directory
- *
- * Uses system commands for extraction:
- * - .tar.gz: `tar -xzf` (macOS/Linux)
- * - .zip: `unzip` (macOS/Linux) or PowerShell `Expand-Archive` (Windows)
- *
- * @param options - Extraction options
- * @returns Extraction result
+ * Binary resolver for moss plugins
  *
- * @example
- * ```typescript
- * const result = await extractArchive({
- *   archivePath: "/path/to/hugo.tar.gz",
- *   destDir: "/path/to/extract/",
- * });
+ * Thin wrapper around the Rust-side unified binary resolver exposed via Tauri command.
+ * All resolution logic (PATH lookup, cache check, download, extraction) happens in Rust.
  *
- * if (!result.success) {
- *   console.error(`Extraction failed: ${result.error}`);
- * }
- * ```
+ * TypeScript types here mirror the Rust serde shapes from binary_resolver.rs.
  */
-declare function extractArchive(options: ExtractOptions): Promise<ExtractResult>;
 /**
- * Make a file executable (Unix only)
- *
- * Runs `chmod +x` on the specified file. No-op on Windows.
- *
- * @param filePath - Absolute path to the file
- * @returns Whether the operation succeeded
- *
- * @example
- * ```typescript
- * await makeExecutable("/path/to/binary");
- * ```
- */
-declare function makeExecutable(filePath: string): Promise<boolean>;
-//#endregion
-//#region src/utils/binary-resolver.d.ts
-/**
- * GitHub source configuration for binary downloads
+ * GitHub Releases download source.
  */
 interface GitHubSource {
   /** Repository owner (e.g., "gohugoio") */
   owner: string;
   /** Repository name (e.g., "hugo") */
   repo: string;
-  /**
-   * Asset filename pattern with placeholders:
-   * - {version}: Version number (e.g., "0.139.0")
-   * - {os}: Operating system (darwin, linux, windows)
-   * - {arch}: Architecture (arm64, amd64, x64)
-   *
-   * Example: "hugo_extended_{version}_{os}-{arch}.tar.gz"
-   */
-  assetPattern: string;
+  /** Asset filename pattern with placeholders: {version}, {os}, {arch} */
+  asset_pattern: string;
+  /** Specific release tag (e.g., "v0.123.0"). If null, fetches "latest". */
+  tag?: string | null;
 }
 /**
- * Binary source configuration per platform
+ * Archive format for downloaded binaries.
+ */
+type ArchiveFormat = "tar_gz" | "zip" | "raw";
+/**
+ * Platform-specific download source for a binary.
  */
 interface BinarySource {
-  /** GitHub release source */
-  github?: GitHubSource;
-  /** Direct download URL (with same placeholders as assetPattern) */
-  directUrl?: string;
+  /** Fetch a release asset via the GitHub Releases API. */
+  github?: GitHubSource | null;
+  /** A pinned URL to download from directly (no API call needed). */
+  direct_url?: string | null;
+  /** Expected SHA-256 checksum of the downloaded file (hex string). */
+  sha256?: string | null;
+  /** Archive format of the downloaded file. */
+  archive_format?: ArchiveFormat | null;
+}
+/**
+ * How to verify a binary works and extract its version.
+ */
+interface VersionCheck {
+  /** Arguments to pass (e.g., ["--version"]) */
+  args: string[];
+  /** Regex pattern with one capture group to extract the version string. */
+  pattern?: string | null;
 }
 /**
- * Configuration for a binary to resolve
+ * Describes the internal layout of an archive for complex distributions.
+ */
+interface ArchiveLayout {
+  /** Path to the main binary inside the archive (e.g., "bin/git"). */
+  binary_path: string;
+  /** Directories where all files need chmod +x after extraction. */
+  executable_dirs: string[];
+}
+/**
+ * Configuration for a binary that can be resolved, cached, and downloaded.
+ *
+ * Platform-specific sources are keyed by platform string
+ * (e.g., "darwin-arm64", "darwin-x64", "linux-x64", "windows-x64").
  */
 interface BinaryConfig {
-  /** Binary name (e.g., "hugo") */
+  /** Human-readable name (e.g., "hugo", "ffmpeg", "git") */
   name: string;
-  /** Minimum version required (semver, optional) */
-  minVersion?: string;
-  /** Command to check version (default: "{name} version") */
-  versionCommand?: string;
-  /** Regex to extract version from command output */
-  versionPattern?: RegExp;
-  /** Download sources per platform */
-  sources: Partial<Record<PlatformKey, BinarySource>>;
-  /** Binary filename inside archive (default: same as name, or name.exe on Windows) */
-  binaryName?: string;
+  /** Filename of the binary if different from name. */
+  binary_name?: string | null;
+  /** How to verify the binary works and extract its version string. */
+  version_check?: VersionCheck | null;
+  /** Platform-specific download sources, keyed by platform string. */
+  sources: Record<string, BinarySource>;
+  /** For complex archives where the binary is nested inside the archive. */
+  archive_layout?: ArchiveLayout | null;
+  /** Subdirectory under ~/.moss/bin/ for caching. */
+  cache_dir?: string | null;
+  /** Minimum disk space required (in bytes) before attempting a download. */
+  required_disk_space?: number | null;
 }
 /**
- * Result of binary resolution
+ * How the binary was found during resolution.
+ */
+type ResolutionSource = "configured_path" | "system_path" | "cache" | "downloaded";
+/**
+ * The result of successfully resolving a binary.
  */
 interface BinaryResolution {
-  /** Absolute path to the binary */
+  /** Absolute path to the binary (or just the name if found in system PATH). */
   path: string;
-  /** Detected version (if available) */
-  version?: string;
-  /** How the binary was found */
-  source: "config" | "path" | "plugin-storage" | "downloaded";
+  /** Version string extracted from the binary output, if available. */
+  version?: string | null;
+  /** How the binary was found. */
+  source: ResolutionSource;
 }
 /**
  * Options for binary resolution
  */
 interface ResolveBinaryOptions {
-  /** Plugin's configured binary path (from context.config) */
+  /** User-configured binary path to check first. */
   configuredPath?: string;
-  /** Whether to auto-download if not found (default: true) */
+  /** Whether to auto-download if not found (default: true). */
   autoDownload?: boolean;
-  /** Progress callback for UI feedback */
-  onProgress?: (phase: string, message: string) => void;
+  /** Progress callback for download UI feedback. */
+  onProgress?: (binary: string, bytesDownloaded: number, totalBytes?: number) => void;
 }
 /**
  * Error thrown during binary resolution
@@ -1113,37 +1617,43 @@ declare class BinaryResolutionError extends Error {
   constructor(message: string, phase: "detection" | "download" | "extraction" | "validation", cause?: Error | undefined);
 }
 /**
- * Resolve a binary, downloading if necessary
+ * Resolve a binary by invoking the Rust-side unified resolver via Tauri command.
  *
- * Resolution order:
- * 1. Configured path (from plugin config, e.g., hugo_path)
- * 2. System PATH (just the binary name)
- * 3. Plugin bin directory (.moss/plugins/{plugin}/bin/{name})
- * 4. Download from GitHub releases (if autoDownload is true)
+ * Resolution order (handled in Rust):
+ * 1. Check configured path (if provided)
+ * 2. Check system PATH
+ * 3. Check ~/.moss/bin/ cache
+ * 4. Download from configured source (if autoDownload is true)
  *
- * @param config - Binary configuration
- * @param options - Resolution options
- * @returns Resolution result with path and source
+ * @param config - Binary configuration matching the Rust BinaryConfig shape
+ * @param options - Resolution options (configured path, auto-download, progress callback)
+ * @returns Resolution result with path, version, and source
  * @throws BinaryResolutionError if binary cannot be resolved
  *
  * @example
  * ```typescript
- * const hugo = await resolveBinary(HUGO_CONFIG, {
+ * const resolution = await resolveBinary({
+ *   name: "hugo",
+ *   version_check: { args: ["version"], pattern: "v(\\d+\\.\\d+\\.\\d+)" },
+ *   sources: {
+ *     "darwin-arm64": {
+ *       github: { owner: "gohugoio", repo: "hugo", asset_pattern: "hugo_extended_{version}_darwin-arm64.tar.gz" },
+ *       archive_format: "tar_gz",
+ *     },
+ *   },
+ * }, {
  *   configuredPath: context.config.hugo_path,
- *   onProgress: (phase, msg) => reportProgress(phase, 0, 1, msg),
+ *   onProgress: (binary, bytes, total) => console.log(`${binary}: ${bytes}/${total}`),
  * });
  *
- * await executeBinary({
- *   binaryPath: hugo.path,
- *   args: ["--version"],
- * });
+ * await executeBinary({ binaryPath: resolution.path, args: ["--version"] });
  * ```
  */
 declare function resolveBinary(config: BinaryConfig, options?: ResolveBinaryOptions): Promise<BinaryResolution>;
 //#endregion
 //#region src/utils/cookies.d.ts
 /**
- * Cookie management for Moss plugins
+ * Cookie management for moss plugins
  *
  * Allows plugins to store and retrieve authentication cookies
  * for external services (e.g., Matters.town, GitHub).
@@ -1210,6 +1720,15 @@ declare function getPluginCookie(): Promise<Cookie[] | null>;
  * ```
  */
 declare function setPluginCookie(cookies: Cookie[]): Promise<void>;
+/**
+ * Delete ALL cookies on the current plugin's registered (manifest) domain from
+ * the shared WebKit store. Used for force-fresh login: clears any lingering
+ * server session so the login webview presents a real credential screen.
+ *
+ * The plugin's identity is auto-detected from the runtime context.
+ * **Must be called from within a plugin hook.**
+ */
+declare function clearPluginCookies(): Promise<void>;
 //#endregion
 //#region src/utils/events.d.ts
 /**
@@ -1285,13 +1804,13 @@ declare function waitForEvent<T>(event: string, timeoutMs?: number): Promise<T>;
 /**
  * Toast notification utilities for plugins
  *
- * Allows plugins to display toast notifications in the main Moss UI
+ * Allows plugins to display toast notifications in the main moss UI
  * through Tauri's event system.
  *
  * ## Design Principles
  *
  * 1. **Plugin Full Control**: Plugins specify exactly what appears in toast
- * 2. **Minimal Assumptions**: Moss just renders what plugin says
+ * 2. **Minimal Assumptions**: moss just renders what plugin says
  * 3. **Direct Path**: Plugin → showToast() → Frontend renders
  * 4. **Separation of Concerns**: Toast (UX) is separate from HookResult (flow control)
  */
@@ -1355,13 +1874,13 @@ interface ToastOptions {
  */
 type ToastType = ToastVariant;
 /** Event for showing a new toast */
-declare const TOAST_EVENT = "plugin-toast";
+declare const TOAST_EVENT = "show-toast";
 /** Event for updating an existing toast by ID */
-declare const TOAST_UPDATE_EVENT = "plugin-toast-update";
+declare const TOAST_UPDATE_EVENT = "show-toast-update";
 /** Event for dismissing a toast by ID */
-declare const TOAST_DISMISS_EVENT = "plugin-toast-dismiss";
+declare const TOAST_DISMISS_EVENT = "show-toast-dismiss";
 /**
- * Show a toast notification in the main Moss UI
+ * Show a toast notification in the main moss UI
  *
  * @param options - Toast options or simple message string
  *
@@ -1431,5 +1950,5 @@ declare function updateToast(id: string, options: Partial<Omit<ToastOptions, "id
  */
 declare function dismissToast(id: string): Promise<void>;
 //#endregion
-export { AfterDeployContext, ArchType, ArchiveFormat, ArticleInfo, BaseContext, BeforeBuildContext, BinaryConfig, BinaryResolution, BinaryResolutionError, BinarySource, BrowserCloseReason, BrowserHandle, CompleteMessage, Cookie, DeploymentInfo, DnsRecord, DnsTarget, DownloadOptions, DownloadResult, ErrorMessage, ExecuteOptions, ExecuteResult, ExtractOptions, ExtractResult, FetchOptions, FetchResult, GetOptions, GitHubSource, HookResult, LogMessage, OSType, OnBuildContext, OnDeployContext, PageNode, PlatformInfo, PlatformKey, PluginCategory, PluginManifest, PluginMessage, PostOptions, ProgressMessage, ProjectInfo, ResolveBinaryOptions, SourceFiles, TOAST_DISMISS_EVENT, TOAST_EVENT, TOAST_UPDATE_EVENT, TauriCore, ToastAction, ToastOptions, ToastType, ToastVariant, clearPlatformCache, closeBrowser, createSymlink, dismissToast, downloadAsset, emitEvent, error, executeBinary, extractArchive, fetchUrl, fileExists, getMessageContext, getPlatformInfo, getPluginCookie, getTauriCore, httpGet, httpPost, isEventApiAvailable, isTauriAvailable, listFiles, listPluginFiles, log, makeExecutable, onEvent, openBrowser, openBrowserWithHtml, openSystemBrowser, pluginFileExists, readFile, readPluginFile, reportComplete, reportError, reportProgress, resolveBinary, sendMessage, setMessageContext, setPluginCookie, showBrowserForm, showToast, updateToast, waitForEvent, warn, writeFile, writePluginFile };
+export { AdvisoryAction, AdvisoryAppOp, AdvisoryProposal, AdvisoryScope, AdvisorySeverity, ArchType, ArchiveLayout, ArticleInfo, BaseContext, ArchiveFormat as BinaryArchiveFormat, BinaryConfig, BinaryResolution, BinaryResolutionError, BinarySource, BrowserCloseReason, BrowserHandle, CompleteMessage, ConfigureDomainContext, Cookie, DeployContext, DeploymentInfo, DnsRecord, DnsTarget, DownloadOptions, DownloadResult, EnhanceContent, EnhanceContext, EnhanceResult, ErrorMessage, EscapeSpec, ExecuteOptions, ExecuteResult, FetchOptions, FetchResult, GenerateContext, GetOptions, GitHubSource, HookResult, LogMessage, MultipartFilePart, MultipartPostOptions, MultipartTextField, OSType, PageNode, PlatformInfo, PlatformKey, PluginCategory, PluginHook, PluginManifest, PluginMessage, PostOptions, ProcessContext, ProgressMessage, ProjectFileEntry, ProjectInfo, ResolutionSource, ResolveBinaryOptions, SiteFileInfo, SocialArticleData, SocialComment, SocialDataFile, SourceFiles, StartTaskOptions, SyndicateContext, TOAST_DISMISS_EVENT, TOAST_EVENT, TOAST_UPDATE_EVENT, TaskHandle, TauriCore, ToastAction, ToastOptions, ToastType, ToastVariant, TriggerContext, VersionCheck, clearPlatformCache, clearPluginCookies, closeBrowser, createSymlink, dismissToast, downloadAsset, emitEvent, executeBinary, fetchUrl, fileExists, getMessageContext, getPlatformInfo, getPluginCookie, getPluginEnvVar, getTauriCore, htmlToMarkdown, httpGet, httpPost, httpPostMultipart, isEventApiAvailable, isTauriAvailable, listFiles, listPluginFiles, listProjectTree, listSiteFilesWithSizes, listSocialFiles, listSourceFiles, onEvent, openBrowser, openBrowserWithHtml, openSystemBrowser, pluginFileExists, readFile, readPluginFile, readProjectFileBase64, readSiteFile, reportComplete, reportError, reportProgress, resolveBinary, returnToEditor, sendMessage, setMessageContext, setPluginCookie, showBrowserForm, showToast, startTask, updateToast, waitForEvent, writeFile, writePluginFile };
 //# sourceMappingURL=index.d.mts.map