@fias/arche-sdk 2.3.0 → 2.10.0

package/dist/index.mjs

@@ -1,5 +1,5 @@
 // src/provider.tsx
-import { useEffect, useMemo, useState } from "react";
+import React, { Component, useEffect, useMemo, useState } from "react";
 
 // src/context.ts
 import { createContext } from "react";
@@ -83,6 +83,16 @@ var messageCounter = 0;
 function generateMessageId() {
   return `msg_${Date.now()}_${++messageCounter}`;
 }
+var FiasBridgeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "FiasBridgeError";
+    this.code = code;
+  }
+  toJSON() {
+    return { name: "FiasBridgeError", code: this.code, message: this.message };
+  }
+};
 function mergeThemeWithDefaults(incoming) {
   const defaults = getDefaultTheme(incoming.mode ?? "dark");
   return {
@@ -104,11 +114,27 @@ var FiasBridge = class {
     this.archId = "";
     this.permissions = [];
     this.theme = null;
+    this.vendoredAssets = null;
     this.currentPath = "";
     this.hostOrigin = "";
     this.themeListeners = /* @__PURE__ */ new Set();
     this.navigationListeners = /* @__PURE__ */ new Set();
     this.stepNavigationListeners = /* @__PURE__ */ new Set();
+    // Preview-state preservation (preview mode only). Keyed so multiple
+    // useFiasPreviewState() callers don't collide. Providers produce a snapshot
+    // on `preview_state_capture`; restore listeners receive it after the reload.
+    this.previewStateProviders = /* @__PURE__ */ new Map();
+    this.previewStateRestoreListeners = /* @__PURE__ */ new Map();
+    // A restore payload that arrived before its hook registered (the host
+    // restores on `ready`, but the React effect that registers runs later).
+    // Consumed per-key as listeners register.
+    this.bufferedRestoreState = null;
+    // Realtime subscriptions (ADR-012 Phase M4), keyed by the HOST-MINTED
+    // logical subscriptionId returned from a subscribe-kind entity_invoke.
+    // The plugin never sees grants/topics — the host manages the transport;
+    // these listeners receive typed invalidations and terminal endings.
+    this.subscriptionEventListeners = /* @__PURE__ */ new Map();
+    this.subscriptionEndedListeners = /* @__PURE__ */ new Map();
     this.listening = false;
     this.handleMessage = (event) => {
       const data = event.data;
@@ -127,6 +153,7 @@ var FiasBridge = class {
         this.archId = initMsg.payload.archId;
         this.permissions = initMsg.payload.permissions;
         this.theme = mergeThemeWithDefaults(initMsg.payload.theme);
+        this.vendoredAssets = initMsg.payload.vendoredAssets ?? null;
         this.currentPath = initMsg.payload.currentPath;
         this.initialized = true;
         this.initResolve?.();
@@ -159,6 +186,23 @@ var FiasBridge = class {
         }
         return;
       }
+      if (data.type === "preview_state_capture") {
+        const snapshot = {};
+        for (const [key, provider] of this.previewStateProviders) {
+          try {
+            snapshot[key] = JSON.parse(JSON.stringify(provider()));
+          } catch {
+          }
+        }
+        this.send("preview_state", snapshot);
+        return;
+      }
+      if (data.type === "preview_state_restore") {
+        const state = data.payload ?? {};
+        this.bufferedRestoreState = { ...this.bufferedRestoreState ?? {}, ...state };
+        this.deliverBufferedRestore();
+        return;
+      }
       if (data.type === "stream_token") {
         const { messageId, text } = data;
         const pending = this.pendingRequests.get(messageId);
@@ -167,6 +211,28 @@ var FiasBridge = class {
         }
         return;
       }
+      if (data.type === "subscription_event") {
+        const payload = data.payload;
+        if (typeof payload?.subscriptionId === "string" && payload.event) {
+          const listeners = this.subscriptionEventListeners.get(payload.subscriptionId);
+          if (listeners) {
+            for (const listener of listeners) listener(payload.event);
+          }
+        }
+        return;
+      }
+      if (data.type === "subscription_ended") {
+        const payload = data.payload;
+        if (typeof payload?.subscriptionId === "string" && payload.reason) {
+          const listeners = this.subscriptionEndedListeners.get(payload.subscriptionId);
+          if (listeners) {
+            for (const listener of listeners) listener(payload.reason);
+          }
+          this.subscriptionEventListeners.delete(payload.subscriptionId);
+          this.subscriptionEndedListeners.delete(payload.subscriptionId);
+        }
+        return;
+      }
       if (data.type === "response") {
         const response = data;
         const pending = this.pendingRequests.get(response.messageId);
@@ -174,7 +240,12 @@ var FiasBridge = class {
         clearTimeout(pending.timer);
         this.pendingRequests.delete(response.messageId);
         if (response.error) {
-          pending.reject(new Error(response.error));
+          pending.reject(
+            new FiasBridgeError(
+              response.error || "Bridge request failed",
+              response.errorCode ?? "BRIDGE_ERROR"
+            )
+          );
         } else {
           pending.resolve(response.payload);
         }
@@ -215,7 +286,12 @@ var FiasBridge = class {
    * an out-of-date plugin before it tries to call ops the host removed.
    */
   ready() {
-    this.send("ready", { sdkProtocolVersion: SDK_BRIDGE_PROTOCOL_VERSION });
+    this.send("ready", {
+      sdkProtocolVersion: SDK_BRIDGE_PROTOCOL_VERSION,
+      // Advertise preview-state support so the host can snapshot/restore us
+      // across a preview rebuild. Older SDKs omit this and the host skips it.
+      supportsPreviewState: true
+    });
   }
   /**
    * Request the host to resize the plugin iframe.
@@ -238,7 +314,7 @@ var FiasBridge = class {
       const messageId = generateMessageId();
       const timer = setTimeout(() => {
         this.pendingRequests.delete(messageId);
-        reject(new Error(`Bridge request timed out: ${type}`));
+        reject(new FiasBridgeError(`Bridge request timed out: ${type}`, "TIMEOUT"));
       }, timeoutMs ?? DEFAULT_TIMEOUT_MS);
       this.pendingRequests.set(messageId, {
         resolve,
@@ -257,6 +333,16 @@ var FiasBridge = class {
   getTheme() {
     return this.theme;
   }
+  /**
+   * Asset URLs for a platform-vendored library (init payload), or null when the
+   * host's CDN is unconfigured, the plugin lacks `sandbox:vendored-libraries`,
+   * or the library isn't vendored. Static per session — no update listener
+   * needed. `importSpecifier` is the library's bare module name (e.g.
+   * `'pdfjs-dist'`). See `useFiasVendoredAssets`.
+   */
+  getVendoredAssets(importSpecifier) {
+    return this.vendoredAssets?.[importSpecifier] ?? null;
+  }
   getCurrentPath() {
     return this.currentPath;
   }
@@ -272,6 +358,41 @@ var FiasBridge = class {
     this.stepNavigationListeners.add(listener);
     return () => this.stepNavigationListeners.delete(listener);
   }
+  /**
+   * Opt into preview-state preservation. In the builder preview, an in-place
+   * rebuild reloads the iframe and destroys the plugin's in-memory state (e.g.
+   * a generated report). Registering here lets the host snapshot `getState()`
+   * before the reload and hand it back to `onRestore` afterwards.
+   *
+   * `key` namespaces the snapshot so independent callers don't collide. Outside
+   * preview mode the host never requests a capture, so this is inert. Returns an
+   * unregister function.
+   */
+  registerPreviewState(key, getState, onRestore) {
+    this.previewStateProviders.set(key, getState);
+    this.previewStateRestoreListeners.set(key, onRestore);
+    this.deliverBufferedRestore();
+    return () => {
+      this.previewStateProviders.delete(key);
+      this.previewStateRestoreListeners.delete(key);
+    };
+  }
+  /** Deliver any buffered restore payload to registered listeners (once per key). */
+  deliverBufferedRestore() {
+    if (!this.bufferedRestoreState) return;
+    for (const [key, listener] of this.previewStateRestoreListeners) {
+      if (key in this.bufferedRestoreState) {
+        try {
+          listener(this.bufferedRestoreState[key]);
+        } catch {
+        }
+        delete this.bufferedRestoreState[key];
+      }
+    }
+    if (Object.keys(this.bufferedRestoreState).length === 0) {
+      this.bufferedRestoreState = null;
+    }
+  }
   /**
    * Send a streaming entity_invoke request. Tokens arrive via stream_token
    * messages and are forwarded to the onToken callback. The returned promise
@@ -284,7 +405,7 @@ var FiasBridge = class {
       const messageId = generateMessageId();
       const timer = setTimeout(() => {
         this.pendingRequests.delete(messageId);
-        reject(new Error("Bridge streaming request timed out: entity_invoke"));
+        reject(new FiasBridgeError("Bridge streaming request timed out: entity_invoke", "TIMEOUT"));
       }, 12e4);
       this.pendingRequests.set(messageId, {
         resolve,
@@ -306,12 +427,69 @@ var FiasBridge = class {
     }
     for (const pending of this.pendingRequests.values()) {
       clearTimeout(pending.timer);
-      pending.reject(new Error("Bridge destroyed"));
+      pending.reject(new FiasBridgeError("Bridge destroyed", "BRIDGE_DESTROYED"));
     }
     this.pendingRequests.clear();
     this.themeListeners.clear();
     this.navigationListeners.clear();
     this.stepNavigationListeners.clear();
+    this.previewStateProviders.clear();
+    this.previewStateRestoreListeners.clear();
+    this.bufferedRestoreState = null;
+    this.subscriptionEventListeners.clear();
+    this.subscriptionEndedListeners.clear();
+  }
+  /**
+   * Listens for invalidation events on a logical realtime subscription
+   * (the id returned by a subscribe-kind entity_invoke). Returns an
+   * unsubscribe function for the LISTENER only — releasing the
+   * subscription itself is `releaseSubscription`.
+   */
+  onSubscriptionEvent(subscriptionId, listener) {
+    let set = this.subscriptionEventListeners.get(subscriptionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.subscriptionEventListeners.set(subscriptionId, set);
+    }
+    set.add(listener);
+    return () => {
+      const listeners = this.subscriptionEventListeners.get(subscriptionId);
+      listeners?.delete(listener);
+      if (listeners && listeners.size === 0) {
+        this.subscriptionEventListeners.delete(subscriptionId);
+      }
+    };
+  }
+  /**
+   * Listens for the terminal ending of a logical realtime subscription.
+   * Reasons are a closed union — `authorization_revoked` and
+   * `collection_deleted` are definitive; the rest may be worth a fresh
+   * subscribe once conditions change.
+   */
+  onSubscriptionEnded(subscriptionId, listener) {
+    let set = this.subscriptionEndedListeners.get(subscriptionId);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.subscriptionEndedListeners.set(subscriptionId, set);
+    }
+    set.add(listener);
+    return () => {
+      const listeners = this.subscriptionEndedListeners.get(subscriptionId);
+      listeners?.delete(listener);
+      if (listeners && listeners.size === 0) {
+        this.subscriptionEndedListeners.delete(subscriptionId);
+      }
+    };
+  }
+  /**
+   * Releases one logical realtime subscription (fire-and-forget). The host
+   * refcounts: the underlying socket topic is torn down when the last
+   * logical subscriber releases.
+   */
+  releaseSubscription(subscriptionId) {
+    this.subscriptionEventListeners.delete(subscriptionId);
+    this.subscriptionEndedListeners.delete(subscriptionId);
+    this.send("subscription_unsubscribe", { subscriptionId });
   }
   send(type, payload, messageId) {
     if (typeof window === "undefined") return;
@@ -337,9 +515,156 @@ function resetBridge() {
 }
 
 // src/provider.tsx
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function FiasErrorScreen({
+  error,
+  onReset
+}) {
+  const code = error.code;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "alert",
+      style: {
+        boxSizing: "border-box",
+        minHeight: "100vh",
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "center",
+        justifyContent: "center",
+        gap: "12px",
+        padding: "24px",
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        color: "#1a1a1a",
+        background: "#fff",
+        textAlign: "center"
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: { fontSize: "15px", fontWeight: 600 }, children: "This plugin hit an error" }),
+        /* @__PURE__ */ jsx(
+          "div",
+          {
+            style: {
+              fontSize: "13px",
+              lineHeight: 1.5,
+              maxWidth: "520px",
+              color: "#b00020",
+              wordBreak: "break-word"
+            },
+            children: error.message
+          }
+        ),
+        typeof code === "string" && code.length > 0 ? /* @__PURE__ */ jsxs("div", { style: { fontSize: "11px", color: "#737373" }, children: [
+          "Code: ",
+          code
+        ] }) : null,
+        onReset ? /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onReset,
+            style: {
+              marginTop: "4px",
+              padding: "8px 20px",
+              fontSize: "13px",
+              fontWeight: 600,
+              fontFamily: "inherit",
+              color: "#fff",
+              background: "#1a1a1a",
+              border: "none",
+              borderRadius: "6px",
+              cursor: "pointer"
+            },
+            children: "Try again"
+          }
+        ) : null
+      ]
+    }
+  );
+}
+var PluginErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null, resetCount: 0 };
+    this.handleReset = () => {
+      this.setState((prev) => ({ error: null, resetCount: prev.resetCount + 1 }));
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    console.error("[fias-sdk] Uncaught error in plugin render:", error, info.componentStack);
+  }
+  render() {
+    if (this.state.error) {
+      return /* @__PURE__ */ jsx(FiasErrorScreen, { error: this.state.error, onReset: this.handleReset });
+    }
+    return /* @__PURE__ */ jsx(React.Fragment, { children: this.props.children }, this.state.resetCount);
+  }
+};
+function UnhandledRejectionBanner({
+  message,
+  onDismiss
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      role: "alert",
+      style: {
+        boxSizing: "border-box",
+        display: "flex",
+        alignItems: "center",
+        gap: "10px",
+        padding: "8px 12px",
+        fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif',
+        fontSize: "12px",
+        lineHeight: 1.4,
+        color: "#7a2900",
+        background: "#fff4ec",
+        borderBottom: "1px solid #f0c9ae"
+      },
+      children: [
+        /* @__PURE__ */ jsxs("span", { style: { flex: 1, wordBreak: "break-word" }, children: [
+          "Something went wrong in this app: ",
+          message
+        ] }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onDismiss,
+            "aria-label": "Dismiss",
+            style: {
+              flexShrink: 0,
+              padding: "2px 8px",
+              fontSize: "12px",
+              fontFamily: "inherit",
+              color: "#7a2900",
+              background: "transparent",
+              border: "1px solid #f0c9ae",
+              borderRadius: "4px",
+              cursor: "pointer"
+            },
+            children: "Dismiss"
+          }
+        )
+      ]
+    }
+  );
+}
+function describeRejectionReason(reason) {
+  if (reason instanceof Error) return reason.message || reason.name;
+  if (typeof reason === "string") return reason;
+  try {
+    return JSON.stringify(reason) ?? String(reason);
+  } catch {
+    return String(reason);
+  }
+}
 function FiasProvider({ children }) {
   const [ready, setReady] = useState(false);
+  const [rejectionMessage, setRejectionMessage] = useState(null);
   const bridge = useMemo(() => getBridge(), []);
   useEffect(() => {
     let mounted = true;
@@ -353,15 +678,57 @@ function FiasProvider({ children }) {
       mounted = false;
     };
   }, [bridge]);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    const handler = (event) => {
+      console.error("[fias-sdk] Unhandled rejection:", event.reason);
+      setRejectionMessage(describeRejectionReason(event.reason) || "Unknown error");
+    };
+    window.addEventListener("unhandledrejection", handler);
+    return () => {
+      window.removeEventListener("unhandledrejection", handler);
+    };
+  }, []);
   if (!ready) {
     return null;
   }
-  return /* @__PURE__ */ jsx(FiasBridgeContext.Provider, { value: bridge, children });
+  return /* @__PURE__ */ jsxs(FiasBridgeContext.Provider, { value: bridge, children: [
+    rejectionMessage !== null ? /* @__PURE__ */ jsx(
+      UnhandledRejectionBanner,
+      {
+        message: rejectionMessage,
+        onDismiss: () => setRejectionMessage(null)
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(PluginErrorBoundary, { children })
+  ] });
 }
 
 // src/hooks.ts
 import { useCallback, useContext, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
 import { flushSync } from "react-dom";
+
+// src/entity-ops.ts
+var PLUGIN_STORAGE_ENTITY_ID = "ent_intg_plugin_storage_00000000";
+var PLUGIN_DATASTORE_ENTITY_ID = "ent_intg_plugin_datastore_000000";
+var PLUGIN_WORKSPACES_ENTITY_ID = "ent_intg_plugin_workspaces_00000";
+var PLUGIN_STORE_ENTITY_ID = "ent_intg_plugin_store_0000000000";
+var VAULT_USER_DOCUMENTS_ENTITY_ID = "ent_intg_vault_documents_0000000";
+async function invokeEntityOp(bridge, entityId, op, args = {}) {
+  const res = await bridge.request("entity_invoke", {
+    entityId,
+    payload: { op, ...args }
+  });
+  return res.output;
+}
+async function invokeStoreOp(bridge, op, args = {}) {
+  return bridge.request("entity_invoke", {
+    entityId: PLUGIN_STORE_ENTITY_ID,
+    payload: { op, ...args }
+  });
+}
+
+// src/hooks.ts
 function useBridge() {
   const bridge = useContext(FiasBridgeContext);
   if (!bridge) {
@@ -378,8 +745,10 @@ function createDebouncedWriter(bridge) {
     const { path, content, timerId } = pending;
     if (timerId !== null) clearTimeout(timerId);
     pending = null;
-    bridge.request("storage_write", { path, content }).catch(() => {
-    });
+    invokeEntityOp(bridge, PLUGIN_STORAGE_ENTITY_ID, "write", { path, content }).catch(
+      () => {
+      }
+    );
   }
   function schedule(path, content) {
     const now = Date.now();
@@ -402,15 +771,22 @@ function createDebouncedWriter(bridge) {
 function useFiasUser() {
   const bridge = useBridge();
   const [user, setUser] = useState2(null);
+  const [error, setError] = useState2(null);
   useEffect2(() => {
     let mounted = true;
-    bridge.request("get_user", {}).then((data) => {
-      if (mounted) setUser(data);
-    });
+    bridge.request("get_user", {}).then(
+      (data) => {
+        if (mounted) setUser(data);
+      },
+      (err) => {
+        if (mounted) setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    );
     return () => {
       mounted = false;
     };
   }, [bridge]);
+  if (error) throw error;
   return user;
 }
 function useFiasTheme() {
@@ -421,12 +797,18 @@ function useFiasTheme() {
   }, [bridge]);
   return theme;
 }
+function useFiasVendoredAssets(importSpecifier) {
+  const bridge = useBridge();
+  return bridge.getVendoredAssets(importSpecifier);
+}
 function useFiasStorage() {
   const bridge = useBridge();
   const readFile = useCallback(
     async (path) => {
-      const res = await bridge.request(
-        "storage_read",
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_STORAGE_ENTITY_ID,
+        "read",
         { path }
       );
       return res?.content ?? null;
@@ -435,20 +817,30 @@ function useFiasStorage() {
   );
   const writeFile = useCallback(
     async (path, content) => {
-      await bridge.request("storage_write", { path, content });
+      await invokeEntityOp(bridge, PLUGIN_STORAGE_ENTITY_ID, "write", {
+        path,
+        content
+      });
     },
     [bridge]
   );
   const listFiles = useCallback(
     async (prefix) => {
-      const res = await bridge.request("storage_list", { prefix });
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_STORAGE_ENTITY_ID,
+        "list",
+        { prefix }
+      );
       return res?.files ?? [];
     },
     [bridge]
   );
   const deleteFile = useCallback(
     async (path) => {
-      await bridge.request("storage_delete", { path });
+      await invokeEntityOp(bridge, PLUGIN_STORAGE_ENTITY_ID, "delete", {
+        path
+      });
     },
     [bridge]
   );
@@ -574,6 +966,76 @@ function useBackgroundRemoval() {
   );
   return { removeBackground, isLoading, result, error };
 }
+var CLIENT_ENTITY_INVOKE_TIMEOUT_MS = 12e4;
+function useClientEntity() {
+  const bridge = useBridge();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const invoke = useCallback(
+    async (entityId, input) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        return await bridge.request(
+          "client_entity_invoke",
+          { entityId, input },
+          CLIENT_ENTITY_INVOKE_TIMEOUT_MS
+        );
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [bridge]
+  );
+  return { invoke, isLoading, error };
+}
+var NLLB_TRANSLATION_ENTITY_ID = "ent_intg_nllb_xlate_000000000000";
+var NLLB_LANGUAGES = [
+  { label: "Arabic", code: "arb_Arab" },
+  { label: "Bengali", code: "ben_Beng" },
+  { label: "Bulgarian", code: "bul_Cyrl" },
+  { label: "Catalan", code: "cat_Latn" },
+  { label: "Chinese (Simplified)", code: "zho_Hans" },
+  { label: "Chinese (Traditional)", code: "zho_Hant" },
+  { label: "Croatian", code: "hrv_Latn" },
+  { label: "Czech", code: "ces_Latn" },
+  { label: "Danish", code: "dan_Latn" },
+  { label: "Dutch", code: "nld_Latn" },
+  { label: "English", code: "eng_Latn" },
+  { label: "Finnish", code: "fin_Latn" },
+  { label: "French", code: "fra_Latn" },
+  { label: "German", code: "deu_Latn" },
+  { label: "Greek", code: "ell_Grek" },
+  { label: "Hebrew", code: "heb_Hebr" },
+  { label: "Hindi", code: "hin_Deva" },
+  { label: "Hungarian", code: "hun_Latn" },
+  { label: "Indonesian", code: "ind_Latn" },
+  { label: "Italian", code: "ita_Latn" },
+  { label: "Japanese", code: "jpn_Jpan" },
+  { label: "Korean", code: "kor_Hang" },
+  { label: "Norwegian", code: "nob_Latn" },
+  { label: "Persian", code: "pes_Arab" },
+  { label: "Polish", code: "pol_Latn" },
+  { label: "Portuguese", code: "por_Latn" },
+  { label: "Romanian", code: "ron_Latn" },
+  { label: "Russian", code: "rus_Cyrl" },
+  { label: "Serbian", code: "srp_Cyrl" },
+  { label: "Slovak", code: "slk_Latn" },
+  { label: "Spanish", code: "spa_Latn" },
+  { label: "Swedish", code: "swe_Latn" },
+  { label: "Tamil", code: "tam_Taml" },
+  { label: "Telugu", code: "tel_Telu" },
+  { label: "Thai", code: "tha_Thai" },
+  { label: "Turkish", code: "tur_Latn" },
+  { label: "Ukrainian", code: "ukr_Cyrl" },
+  { label: "Urdu", code: "urd_Arab" },
+  { label: "Vietnamese", code: "vie_Latn" }
+];
+var GRAMMAR_CHECK_ENTITY_ID = "ent_intg_grammar_check_000000000";
 function useAudioGeneration() {
   const bridge = useBridge();
   const [isLoading, setIsLoading] = useState2(false);
@@ -648,7 +1110,13 @@ function useFiasNavigation() {
     },
     [bridge]
   );
-  return { navigateTo, currentPath };
+  const openArche = useCallback(
+    (archeId, opts) => {
+      bridge.request("open_arche", { archeId, newTab: opts?.newTab === true });
+    },
+    [bridge]
+  );
+  return { navigateTo, openArche, currentPath };
 }
 function usePersistentState(key, initialValue) {
   const bridge = useBridge();
@@ -657,7 +1125,7 @@ function usePersistentState(key, initialValue) {
   const valueRef = useRef(initialValue);
   const writer = useMemo2(() => createDebouncedWriter(bridge), [bridge]);
   useEffect2(() => {
-    bridge.request("storage_read", { path: `__state/${key}` }).then((result) => {
+    invokeEntityOp(bridge, PLUGIN_STORAGE_ENTITY_ID, "read", { path: `__state/${key}` }).then((result) => {
       if (result.exists && result.content !== null) {
         try {
           const parsed = JSON.parse(result.content);
@@ -667,6 +1135,8 @@ function usePersistentState(key, initialValue) {
         }
       }
       initializedRef.current = true;
+    }).catch(() => {
+      initializedRef.current = true;
     });
     return () => {
       writer.flush();
@@ -695,9 +1165,12 @@ function useStepNavigation(initialStep, options) {
       return;
     }
     let cancelled = false;
-    bridge.request("storage_read", {
-      path: `__state/${persistKey}`
-    }).then((result) => {
+    invokeEntityOp(
+      bridge,
+      PLUGIN_STORAGE_ENTITY_ID,
+      "read",
+      { path: `__state/${persistKey}` }
+    ).then((result) => {
       if (cancelled || initializedRef.current) return;
       if (result.exists && result.content !== null) {
         try {
@@ -741,55 +1214,103 @@ function useFiasDataStore() {
   const bridge = useBridge();
   const createCollection = useCallback(
     async (name, options) => {
-      const res = await bridge.request(
-        "data_create_collection",
-        { name, userScope: options?.userScope ?? "user" }
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "create_collection",
+        {
+          name,
+          userScope: options?.userScope ?? "user",
+          searchable: options?.searchable,
+          writeMinRole: options?.writeMinRole,
+          readMinRole: options?.readMinRole
+        }
       );
       return res.collection;
     },
     [bridge]
   );
   const listCollections = useCallback(async () => {
-    const res = await bridge.request(
-      "data_list_collections",
-      {}
+    const res = await invokeEntityOp(
+      bridge,
+      PLUGIN_DATASTORE_ENTITY_ID,
+      "list_collections"
     );
     return res.collections;
   }, [bridge]);
   const deleteCollection = useCallback(
     async (name) => {
-      await bridge.request("data_delete_collection", { name });
+      await invokeEntityOp(bridge, PLUGIN_DATASTORE_ENTITY_ID, "delete_collection", { name });
     },
     [bridge]
   );
   const put = useCallback(
-    async (collection, key, data) => {
-      await bridge.request("data_put", { collection, key, data });
+    async (collection, key, data, options) => {
+      await invokeEntityOp(bridge, PLUGIN_DATASTORE_ENTITY_ID, "put", {
+        collection,
+        key,
+        data,
+        workspaceId: options?.workspaceId
+      });
     },
     [bridge]
   );
   const get = useCallback(
-    async (collection, key) => {
-      const res = await bridge.request("data_get", {
-        collection,
-        key
-      });
+    async (collection, key, options) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "get",
+        {
+          collection,
+          key,
+          workspaceId: options?.workspaceId
+        }
+      );
       return res.data;
     },
     [bridge]
   );
   const query = useCallback(
-    async (collection, options) => {
-      return bridge.request("data_query", {
+    async (collection, options, scope) => {
+      return invokeEntityOp(bridge, PLUGIN_DATASTORE_ENTITY_ID, "query", {
         collection,
-        ...options
+        ...options,
+        workspaceId: scope?.workspaceId
       });
     },
     [bridge]
   );
+  const search = useCallback(
+    async (collection, queryText, options, scope) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "search",
+        {
+          collection,
+          query: queryText,
+          ...options,
+          workspaceId: scope?.workspaceId
+        }
+      );
+      return res.matches;
+    },
+    [bridge]
+  );
   const deleteDoc = useCallback(
-    async (collection, key) => {
-      await bridge.request("data_delete", { collection, key });
+    async (collection, key, options) => {
+      await invokeEntityOp(bridge, PLUGIN_DATASTORE_ENTITY_ID, "delete", {
+        collection,
+        key,
+        workspaceId: options?.workspaceId
+      });
+    },
+    [bridge]
+  );
+  const batch = useCallback(
+    async (operations) => {
+      await invokeEntityOp(bridge, PLUGIN_DATASTORE_ENTITY_ID, "batch", { operations });
     },
     [bridge]
   );
@@ -801,9 +1322,116 @@ function useFiasDataStore() {
       put,
       get,
       query,
-      delete: deleteDoc
+      search,
+      delete: deleteDoc,
+      batch
     }),
-    [createCollection, listCollections, deleteCollection, put, get, query, deleteDoc]
+    [
+      createCollection,
+      listCollections,
+      deleteCollection,
+      put,
+      get,
+      query,
+      search,
+      deleteDoc,
+      batch
+    ]
+  );
+}
+function useFiasWorkspaces() {
+  const bridge = useBridge();
+  const create = useCallback(
+    async (displayName) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_WORKSPACES_ENTITY_ID,
+        "create",
+        { displayName }
+      );
+      return res.workspace;
+    },
+    [bridge]
+  );
+  const list = useCallback(async () => {
+    const res = await invokeEntityOp(
+      bridge,
+      PLUGIN_WORKSPACES_ENTITY_ID,
+      "list"
+    );
+    return res.workspaces;
+  }, [bridge]);
+  const get = useCallback(
+    async (workspaceId) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_WORKSPACES_ENTITY_ID,
+        "get",
+        { workspaceId }
+      );
+      return res.workspace;
+    },
+    [bridge]
+  );
+  const archive = useCallback(
+    async (workspaceId) => {
+      await invokeEntityOp(bridge, PLUGIN_WORKSPACES_ENTITY_ID, "archive", { workspaceId });
+    },
+    [bridge]
+  );
+  const listMembers = useCallback(
+    async (workspaceId) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_WORKSPACES_ENTITY_ID,
+        "list_members",
+        { workspaceId }
+      );
+      return res.members;
+    },
+    [bridge]
+  );
+  const addMember = useCallback(
+    async (workspaceId, username, role, expiresAt) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_WORKSPACES_ENTITY_ID,
+        "add_member",
+        {
+          workspaceId,
+          username,
+          role,
+          expiresAt
+        }
+      );
+      return res.member;
+    },
+    [bridge]
+  );
+  const updateMember = useCallback(
+    async (workspaceId, username, role) => {
+      const res = await invokeEntityOp(
+        bridge,
+        PLUGIN_WORKSPACES_ENTITY_ID,
+        "update_member",
+        { workspaceId, username, role }
+      );
+      return res.member;
+    },
+    [bridge]
+  );
+  const removeMember = useCallback(
+    async (workspaceId, username) => {
+      await invokeEntityOp(bridge, PLUGIN_WORKSPACES_ENTITY_ID, "remove_member", {
+        workspaceId,
+        username
+      });
+    },
+    [bridge]
+  );
+  return useMemo2(
+    () => ({ create, list, get, archive, listMembers, addMember, updateMember, removeMember }),
+    [create, list, get, archive, listMembers, addMember, updateMember, removeMember]
   );
 }
 function useFiasStore() {
@@ -814,8 +1442,8 @@ function useFiasStore() {
   useEffect2(() => {
     let mounted = true;
     Promise.all([
-      bridge.request("store_get_products", {}),
-      bridge.request("store_get_entitlements", {})
+      invokeStoreOp(bridge, "get_products"),
+      invokeStoreOp(bridge, "get_entitlements")
     ]).then(([prods, ents]) => {
       if (mounted) {
         setProducts(prods);
@@ -831,7 +1459,7 @@ function useFiasStore() {
   }, [bridge]);
   const purchase = useCallback(
     async (productIdentifier, options) => {
-      const result = await bridge.request("store_purchase", {
+      const result = await invokeStoreOp(bridge, "purchase", {
         productIdentifier,
         ...options
       });
@@ -859,14 +1487,11 @@ function useFiasStore() {
     [entitlements]
   );
   const getPurchaseHistory = useCallback(async () => {
-    const res = await bridge.request(
-      "store_get_purchase_history",
-      {}
-    );
+    const res = await invokeStoreOp(bridge, "get_purchase_history");
     return res.purchases;
   }, [bridge]);
   const restorePurchases = useCallback(async () => {
-    const restored = await bridge.request("store_restore", {});
+    const restored = await invokeStoreOp(bridge, "restore");
     setEntitlements(restored);
     return restored;
   }, [bridge]);
@@ -1039,29 +1664,17 @@ function useVaultDocuments() {
   const upload = useCallback(
     async (bytes, params) => {
       const src = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
-      const u8 = new Uint8Array(src.byteLength);
-      u8.set(src);
-      const sizeBytes = u8.byteLength;
-      const digest = await crypto.subtle.digest("SHA-256", u8);
-      const checksumHex = bytesToHex(new Uint8Array(digest));
-      const init = await uploadInit({ ...params, sizeBytes, checksumSha256: checksumHex });
-      const browserHeaders = Object.fromEntries(
-        Object.entries(init.requiredHeaders).filter(([k]) => k.toLowerCase() !== "content-length")
-      );
-      const putResp = await fetch(init.uploadUrl, {
-        method: "PUT",
-        body: u8,
-        headers: browserHeaders
+      return bridge.request("vault_documents_upload", {
+        name: params.name,
+        mimeType: params.mimeType,
+        bytes: bytesToBase64(src),
+        tags: params.tags,
+        sensitivity: params.sensitivity,
+        folderPath: params.folderPath,
+        replacesDocumentId: params.replacesDocumentId
       });
-      if (!putResp.ok) {
-        const text = await putResp.text().catch(() => "");
-        throw new Error(
-          `Vault upload PUT failed (${putResp.status}): ${text || putResp.statusText}`
-        );
-      }
-      return uploadFinalize({ documentId: init.documentId, checksumSha256: checksumHex });
     },
-    [uploadInit, uploadFinalize]
+    [bridge]
   );
   return useMemo2(
     () => ({
@@ -1094,12 +1707,13 @@ function useVaultDocuments() {
     ]
   );
 }
-function bytesToHex(bytes) {
-  let out = "";
-  for (let i = 0; i < bytes.length; i++) {
-    out += bytes[i].toString(16).padStart(2, "0");
+function bytesToBase64(bytes) {
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
   }
-  return out;
+  return btoa(binary);
 }
 function useArcheAssets() {
   const bridge = useBridge();
@@ -1130,6 +1744,136 @@ function useArcheAssets() {
   );
   return useMemo2(() => ({ list, index, getUrl }), [list, index, getUrl]);
 }
+function useFiasPreviewState(key, getState, onRestore) {
+  const bridge = useBridge();
+  const getStateRef = useRef(getState);
+  getStateRef.current = getState;
+  const onRestoreRef = useRef(onRestore);
+  onRestoreRef.current = onRestore;
+  useEffect2(() => {
+    return bridge.registerPreviewState(
+      key,
+      () => getStateRef.current(),
+      (state) => onRestoreRef.current(state)
+    );
+  }, [bridge, key]);
+}
+function useDataSubscription(collection, onInvalidate, options) {
+  const bridge = useBridge();
+  const [state, setState] = useState2({ status: "subscribing" });
+  const onInvalidateRef = useRef(onInvalidate);
+  onInvalidateRef.current = onInvalidate;
+  const enabled = options?.enabled ?? true;
+  const workspaceId = options?.workspaceId;
+  useEffect2(() => {
+    if (!enabled) {
+      setState({ status: "ended", endedReason: "unsubscribed" });
+      return;
+    }
+    let cancelled = false;
+    let subscriptionId = null;
+    let unsubscribeEvent = null;
+    let unsubscribeEnded = null;
+    let refetching = false;
+    let trailing = false;
+    const runInvalidate = async () => {
+      if (refetching) {
+        trailing = true;
+        return;
+      }
+      refetching = true;
+      try {
+        await onInvalidateRef.current();
+      } catch {
+      }
+      refetching = false;
+      if (trailing && !cancelled) {
+        trailing = false;
+        void runInvalidate();
+      }
+    };
+    setState({ status: "subscribing" });
+    void (async () => {
+      try {
+        const res = await bridge.request("entity_invoke", {
+          entityId: PLUGIN_DATASTORE_ENTITY_ID,
+          payload: { op: "subscribe", collection, workspaceId }
+        });
+        const subscription = res?.output;
+        if (!subscription || subscription.kind !== "subscription" || typeof subscription.subscriptionId !== "string") {
+          if (!cancelled) setState({ status: "ended", endedReason: "transport_error" });
+          return;
+        }
+        if (cancelled) {
+          bridge.releaseSubscription(subscription.subscriptionId);
+          return;
+        }
+        subscriptionId = subscription.subscriptionId;
+        unsubscribeEvent = bridge.onSubscriptionEvent(subscriptionId, () => void runInvalidate());
+        unsubscribeEnded = bridge.onSubscriptionEnded(subscriptionId, (reason) => {
+          if (!cancelled) setState({ status: "ended", endedReason: reason });
+        });
+        setState({ status: "active" });
+        void runInvalidate();
+      } catch {
+        if (!cancelled) setState({ status: "ended", endedReason: "transport_error" });
+      }
+    })();
+    return () => {
+      cancelled = true;
+      unsubscribeEvent?.();
+      unsubscribeEnded?.();
+      if (subscriptionId) bridge.releaseSubscription(subscriptionId);
+    };
+  }, [bridge, collection, workspaceId, enabled]);
+  return state;
+}
+function useVaultUserDocuments() {
+  const bridge = useBridge();
+  const pick = useCallback(
+    async (options) => {
+      return bridge.request("vault_documents_pick", {
+        maxDocuments: options?.maxDocuments
+      });
+    },
+    [bridge]
+  );
+  const list = useCallback(
+    async (options) => {
+      const res = await invokeEntityOp(
+        bridge,
+        VAULT_USER_DOCUMENTS_ENTITY_ID,
+        "list_consented_documents",
+        { limit: options?.limit, offset: options?.offset }
+      );
+      return res.documents;
+    },
+    [bridge]
+  );
+  const get = useCallback(
+    async (documentId, options) => {
+      return invokeEntityOp(
+        bridge,
+        VAULT_USER_DOCUMENTS_ENTITY_ID,
+        "get_consented_document",
+        { documentId, includeContent: options?.includeContent }
+      );
+    },
+    [bridge]
+  );
+  const getDownloadUrl = useCallback(
+    async (documentId) => {
+      const res = await invokeEntityOp(bridge, VAULT_USER_DOCUMENTS_ENTITY_ID, "get_consented_document_url", { documentId });
+      return {
+        url: res.url,
+        expiresAt: new Date(res.expiresAt).getTime(),
+        contentType: res.contentType
+      };
+    },
+    [bridge]
+  );
+  return useMemo2(() => ({ pick, list, get, getDownloadUrl }), [pick, list, get, getDownloadUrl]);
+}
 
 // src/generated/surfaces.ts
 var AUDIO_AUDIO_ISOLATION_SURFACE_KEY = "audio.audio-isolation";
@@ -1158,25 +1902,91 @@ var AUDIO_VOICE_DESIGN_SURFACE_KEY = "audio.voice-design";
 var useElevenLabsVoiceDesign = () => useSurface(
   AUDIO_VOICE_DESIGN_SURFACE_KEY
 );
+var IMAGE_SMART_CONTROL_SURFACE_KEY = "image.smart-control";
+var useSmartControl = () => useSurface(IMAGE_SMART_CONTROL_SURFACE_KEY);
+var IMAGE_SMART_ERASE_SURFACE_KEY = "image.smart-erase";
+var useSmartErase = () => useSurface(IMAGE_SMART_ERASE_SURFACE_KEY);
+var IMAGE_SMART_IMAGE_TO_IMAGE_SURFACE_KEY = "image.smart-image-to-image";
+var useSmartImageToImage = () => useSurface(
+  IMAGE_SMART_IMAGE_TO_IMAGE_SURFACE_KEY
+);
+var IMAGE_SMART_INPAINT_SURFACE_KEY = "image.smart-inpaint";
+var useSmartInpaint = () => useSurface(IMAGE_SMART_INPAINT_SURFACE_KEY);
+var IMAGE_SMART_OUTPAINT_SURFACE_KEY = "image.smart-outpaint";
+var useSmartOutpaint = () => useSurface(IMAGE_SMART_OUTPAINT_SURFACE_KEY);
+var IMAGE_SMART_REMOVE_BACKGROUND_SURFACE_KEY = "image.smart-remove-background";
+var useSmartRemoveBackground = () => useSurface(
+  IMAGE_SMART_REMOVE_BACKGROUND_SURFACE_KEY
+);
+var IMAGE_SMART_REPLACE_BACKGROUND_SURFACE_KEY = "image.smart-replace-background";
+var useSmartReplaceBackground = () => useSurface(
+  IMAGE_SMART_REPLACE_BACKGROUND_SURFACE_KEY
+);
+var IMAGE_SMART_SEARCH_RECOLOR_SURFACE_KEY = "image.smart-search-recolor";
+var useSmartSearchRecolor = () => useSurface(
+  IMAGE_SMART_SEARCH_RECOLOR_SURFACE_KEY
+);
+var IMAGE_SMART_SEARCH_REPLACE_SURFACE_KEY = "image.smart-search-replace";
+var useSmartSearchReplace = () => useSurface(
+  IMAGE_SMART_SEARCH_REPLACE_SURFACE_KEY
+);
+var IMAGE_SMART_UPSCALE_SURFACE_KEY = "image.smart-upscale";
+var useSmartUpscale = () => useSurface(IMAGE_SMART_UPSCALE_SURFACE_KEY);
+var IMAGE_SMART_VECTORIZE_SURFACE_KEY = "image.smart-vectorize";
+var useSmartVectorize = () => useSurface(IMAGE_SMART_VECTORIZE_SURFACE_KEY);
+var INTEGRATION_WEB_SEARCH_SURFACE_KEY = "integration.web-search";
+var useIntegrationWebSearch = () => useSurface(
+  INTEGRATION_WEB_SEARCH_SURFACE_KEY
+);
 
 // src/generated/permissions.ts
 var VALID_PLUGIN_PERMISSIONS = [
   "assets:read",
+  "data:search",
   "data:store",
+  "data:workspace",
   "entities:audio_generate",
+  "entities:client_invoke",
+  "entities:image_edit",
   "entities:image_generate",
   "entities:image_remove_background",
   "entities:invoke",
+  "entities:web_search",
+  "navigation:open_arche",
+  "sandbox:vendored-libraries",
   "storage:sandbox",
   "store:purchase",
   "theme:read",
   "user:profile:read",
   "vault:documents:read",
-  "vault:documents:write"
+  "vault:documents:write",
+  "vault:user-documents:read"
 ];
 function isValidPluginPermission(perm) {
   return VALID_PLUGIN_PERMISSIONS.includes(perm);
 }
+var PLUGIN_PERMISSION_DESCRIPTIONS = {
+  "assets:read": "Show images from this app's published asset library.",
+  "data:search": "Search this app's own data semantically \u2014 costs credits per search.",
+  "data:store": "Save structured data in this app's own private database.",
+  "data:workspace": "Create team workspaces and manage their members.",
+  "entities:audio_generate": "Generate audio with platform AI \u2014 costs credits.",
+  "entities:client_invoke": "Use free on-device tools (grammar check, translation, background removal) in your browser.",
+  "entities:image_edit": "Edit images with platform AI \u2014 costs credits.",
+  "entities:image_generate": "Generate images with platform AI \u2014 costs credits.",
+  "entities:image_remove_background": "Remove image backgrounds.",
+  "entities:invoke": "Use platform AI (text) on your behalf \u2014 costs credits.",
+  "entities:web_search": "Search the live web on your behalf \u2014 costs credits.",
+  "navigation:open_arche": "Open other arches for you (navigation only).",
+  "sandbox:vendored-libraries": "Load platform-hosted libraries (like the PDF renderer) from the trusted CDN.",
+  "storage:sandbox": "Save files in this app's own private storage.",
+  "store:purchase": "Offer in-app purchases (you approve each purchase).",
+  "theme:read": "Match your platform theme.",
+  "user:profile:read": "See your display name and avatar.",
+  "vault:documents:read": "Read documents this app itself created in your Vault.",
+  "vault:documents:write": "Create and manage its own documents in your Vault.",
+  "vault:user-documents:read": "Read documents YOU choose to share with it from your Vault \u2014 you pick each document, and you can remove access any time in Vault \u2192 App Access."
+};
 
 // src/fias.ts
 var fias = {
@@ -1206,40 +2016,64 @@ var fias = {
    */
   dataStore: {
     async createCollection(name, options) {
-      const res = await getBridge().request(
-        "data_create_collection",
-        { name, userScope: options?.userScope ?? "user" }
+      const res = await invokeEntityOp(
+        getBridge(),
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "create_collection",
+        { name, userScope: options?.userScope ?? "user", searchable: options?.searchable }
       );
       return res.collection;
     },
     async listCollections() {
-      const res = await getBridge().request(
-        "data_list_collections",
-        {}
+      const res = await invokeEntityOp(
+        getBridge(),
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "list_collections"
       );
       return res.collections;
     },
     async deleteCollection(name) {
-      await getBridge().request("data_delete_collection", { name });
+      await invokeEntityOp(getBridge(), PLUGIN_DATASTORE_ENTITY_ID, "delete_collection", { name });
     },
     async put(collection, key, data) {
-      await getBridge().request("data_put", { collection, key, data });
-    },
-    async get(collection, key) {
-      const res = await getBridge().request("data_get", {
+      await invokeEntityOp(getBridge(), PLUGIN_DATASTORE_ENTITY_ID, "put", {
         collection,
-        key
+        key,
+        data
       });
+    },
+    async get(collection, key) {
+      const res = await invokeEntityOp(
+        getBridge(),
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "get",
+        { collection, key }
+      );
       return res.data;
     },
     async query(collection, options) {
-      return getBridge().request("data_query", {
-        collection,
-        ...options
-      });
+      return invokeEntityOp(
+        getBridge(),
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "query",
+        { collection, ...options }
+      );
+    },
+    async search(collection, query, options) {
+      const res = await invokeEntityOp(
+        getBridge(),
+        PLUGIN_DATASTORE_ENTITY_ID,
+        "search",
+        { collection, query, ...options }
+      );
+      return res.matches;
     },
     async delete(collection, key) {
-      await getBridge().request("data_delete", { collection, key });
+      await invokeEntityOp(getBridge(), PLUGIN_DATASTORE_ENTITY_ID, "delete", { collection, key });
+    },
+    /** Apply up to 25 put/delete ops in one all-or-nothing transaction. */
+    async batch(operations) {
+      await invokeEntityOp(getBridge(), PLUGIN_DATASTORE_ENTITY_ID, "batch", { operations });
     }
   }
 };
@@ -3214,8 +4048,25 @@ export {
   FONT_CATALOG,
   FONT_PAIRINGS,
   FiasBridge,
+  FiasBridgeError,
   FiasProvider,
+  GRAMMAR_CHECK_ENTITY_ID,
+  IMAGE_SMART_CONTROL_SURFACE_KEY,
+  IMAGE_SMART_ERASE_SURFACE_KEY,
+  IMAGE_SMART_IMAGE_TO_IMAGE_SURFACE_KEY,
+  IMAGE_SMART_INPAINT_SURFACE_KEY,
+  IMAGE_SMART_OUTPAINT_SURFACE_KEY,
+  IMAGE_SMART_REMOVE_BACKGROUND_SURFACE_KEY,
+  IMAGE_SMART_REPLACE_BACKGROUND_SURFACE_KEY,
+  IMAGE_SMART_SEARCH_RECOLOR_SURFACE_KEY,
+  IMAGE_SMART_SEARCH_REPLACE_SURFACE_KEY,
+  IMAGE_SMART_UPSCALE_SURFACE_KEY,
+  IMAGE_SMART_VECTORIZE_SURFACE_KEY,
+  INTEGRATION_WEB_SEARCH_SURFACE_KEY,
   LIGHT_THEME,
+  NLLB_LANGUAGES,
+  NLLB_TRANSLATION_ENTITY_ID,
+  PLUGIN_PERMISSION_DESCRIPTIONS,
   SDK_BRIDGE_PROTOCOL_VERSION,
   SDK_REQUIRES_HOST_PROTOCOL_VERSION,
   THEME_CATALOG,
@@ -3232,6 +4083,8 @@ export {
   useArcheAssets,
   useAudioGeneration,
   useBackgroundRemoval,
+  useClientEntity,
+  useDataSubscription,
   useElevenLabsAudioIsolation,
   useElevenLabsForcedAlignment,
   useElevenLabsMusic,
@@ -3244,15 +4097,31 @@ export {
   useFiasDataStore,
   useFiasFonts,
   useFiasNavigation,
+  useFiasPreviewState,
   useFiasStorage,
   useFiasStore,
   useFiasTheme,
   useFiasUser,
+  useFiasVendoredAssets,
+  useFiasWorkspaces,
   useImageEntities,
   useImageGeneration,
+  useIntegrationWebSearch,
   useLyriaMusic,
   usePersistentState,
+  useSmartControl,
+  useSmartErase,
+  useSmartImageToImage,
+  useSmartInpaint,
+  useSmartOutpaint,
+  useSmartRemoveBackground,
+  useSmartReplaceBackground,
+  useSmartSearchRecolor,
+  useSmartSearchReplace,
+  useSmartUpscale,
+  useSmartVectorize,
   useStepNavigation,
   useSurface,
-  useVaultDocuments
+  useVaultDocuments,
+  useVaultUserDocuments
 };