@fias/arche-sdk 1.9.0 → 1.12.0

package/dist/index.mjs

@@ -497,6 +497,60 @@ function useImageGeneration() {
   );
   return { generate, isLoading, result, error };
 }
+function useAudioGeneration() {
+  const bridge = useBridge();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [result, setResult] = useState2(null);
+  const [error, setError] = useState2(null);
+  const generate = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const res = await bridge.request("audio_generate", params, 18e4);
+        setResult(res);
+        return res;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [bridge]
+  );
+  return { generate, isLoading, result, error };
+}
+function useSurface(surfaceKey, timeoutMs = 18e4) {
+  const bridge = useBridge();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [result, setResult] = useState2(null);
+  const [error, setError] = useState2(null);
+  const invoke = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const res = await bridge.request(
+          "surface_invoke",
+          { surfaceKey, params },
+          timeoutMs
+        );
+        setResult(res);
+        return res;
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        throw e;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [bridge, surfaceKey, timeoutMs]
+  );
+  return { invoke, isLoading, result, error };
+}
 function useFiasNavigation() {
   const bridge = useBridge();
   const [currentPath, setCurrentPath] = useState2(bridge.getCurrentPath());
@@ -760,32 +814,44 @@ function useFiasStore() {
     ]
   );
 }
-var FILES_DOWNLOAD_URL_REFRESH_BUFFER_MS = 6e4;
+var DOWNLOAD_URL_REFRESH_BUFFER_MS = 6e4;
 var downloadUrlCache = /* @__PURE__ */ new Map();
 var downloadUrlInflight = /* @__PURE__ */ new Map();
-async function fetchFileDownloadUrl(fileId) {
+async function fetchVaultDocumentDownloadUrl(documentId) {
   const now = Date.now();
-  const cached = downloadUrlCache.get(fileId);
-  if (cached && now < cached.expiresAt - FILES_DOWNLOAD_URL_REFRESH_BUFFER_MS) {
-    return { url: cached.url, expiresAt: cached.expiresAt };
+  const cached = downloadUrlCache.get(documentId);
+  if (cached && now < cached.expiresAt - DOWNLOAD_URL_REFRESH_BUFFER_MS) {
+    return { url: cached.url, expiresAt: cached.expiresAt, contentType: cached.contentType };
   }
-  const inflight = downloadUrlInflight.get(fileId);
+  const inflight = downloadUrlInflight.get(documentId);
   if (inflight) return inflight;
   const bridge = getBridge();
-  const promise = bridge.request("files_download_url", { fileId }).then((result) => {
-    downloadUrlCache.set(fileId, { url: result.url, expiresAt: result.expiresAt });
-    return result;
+  const promise = bridge.request(
+    "vault_documents_download_url",
+    { documentId }
+  ).then((result) => {
+    const normalized = {
+      url: result.url,
+      expiresAt: new Date(result.expiresAt).getTime(),
+      contentType: result.contentType
+    };
+    downloadUrlCache.set(documentId, {
+      url: normalized.url,
+      expiresAt: normalized.expiresAt,
+      contentType: normalized.contentType
+    });
+    return normalized;
   }).finally(() => {
-    downloadUrlInflight.delete(fileId);
+    downloadUrlInflight.delete(documentId);
   });
-  downloadUrlInflight.set(fileId, promise);
+  downloadUrlInflight.set(documentId, promise);
   return promise;
 }
-function useFiasFiles() {
+function useVaultDocuments() {
   const bridge = useBridge();
   const list = useCallback(
     async (options) => {
-      return bridge.request("files_list", {
+      return bridge.request("vault_documents_list", {
         search: options?.search,
         limit: options?.limit,
         cursor: options?.cursor
@@ -794,13 +860,15 @@ function useFiasFiles() {
     [bridge]
   );
   const read = useCallback(
-    async (fileId) => {
-      return bridge.request("files_read", { fileId });
+    async (documentId) => {
+      return bridge.request("vault_documents_read", {
+        documentId
+      });
     },
     [bridge]
   );
   const getDownloadUrl = useCallback(
-    (fileId) => fetchFileDownloadUrl(fileId),
+    (documentId) => fetchVaultDocumentDownloadUrl(documentId),
     // The hook closes over the React context's bridge, but the resolver
     // uses the singleton — they are the same instance in practice. Keeping
     // `bridge` in the deps for symmetry with other hooks that do go through
@@ -809,34 +877,115 @@ function useFiasFiles() {
   );
   const write = useCallback(
     async (params) => {
-      return bridge.request("files_write", {
+      return bridge.request("vault_documents_write", {
         name: params.name,
         content: params.content,
         contentType: params.contentType,
-        tags: params.tags
+        tags: params.tags,
+        sensitivity: params.sensitivity,
+        folderPath: params.folderPath,
+        replacesDocumentId: params.replacesDocumentId
       });
     },
     [bridge]
   );
   const update = useCallback(
-    async (fileId, params) => {
-      await bridge.request("files_update", {
-        fileId,
+    async (documentId, params) => {
+      await bridge.request("vault_documents_update", {
+        documentId,
         name: params.name,
         tags: params.tags
       });
-      downloadUrlCache.delete(fileId);
+      downloadUrlCache.delete(documentId);
     },
     [bridge]
   );
-  const deleteFile = useCallback(
-    async (fileId) => {
-      await bridge.request("files_delete", { fileId });
-      downloadUrlCache.delete(fileId);
-      downloadUrlInflight.delete(fileId);
+  const deleteDocument = useCallback(
+    async (documentId) => {
+      await bridge.request("vault_documents_delete", { documentId });
+      downloadUrlCache.delete(documentId);
+      downloadUrlInflight.delete(documentId);
+    },
+    [bridge]
+  );
+  const search = useCallback(
+    async (query, options) => {
+      return bridge.request("vault_documents_search", {
+        query,
+        topK: options?.topK,
+        minSimilarity: options?.minSimilarity,
+        includeContent: options?.includeContent
+      });
+    },
+    [bridge]
+  );
+  const attach = useCallback(
+    async (documentId, target) => {
+      return bridge.request("vault_documents_attach", {
+        documentId,
+        regardingType: target.regardingType,
+        regardingId: target.regardingId
+      });
     },
     [bridge]
   );
+  const detach = useCallback(
+    async (documentId, referenceId) => {
+      await bridge.request("vault_documents_detach", { documentId, referenceId });
+    },
+    [bridge]
+  );
+  const uploadInit = useCallback(
+    async (params) => {
+      return bridge.request("vault_documents_upload_init", {
+        name: params.name,
+        mimeType: params.mimeType,
+        sizeBytes: params.sizeBytes,
+        checksumSha256: params.checksumSha256,
+        tags: params.tags,
+        sensitivity: params.sensitivity,
+        folderPath: params.folderPath,
+        replacesDocumentId: params.replacesDocumentId
+      });
+    },
+    [bridge]
+  );
+  const uploadFinalize = useCallback(
+    async (params) => {
+      return bridge.request("vault_documents_upload_finalize", {
+        documentId: params.documentId,
+        checksumSha256: params.checksumSha256
+      });
+    },
+    [bridge]
+  );
+  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
+      });
+      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]
+  );
   return useMemo2(
     () => ({
       list,
@@ -844,11 +993,102 @@ function useFiasFiles() {
       getDownloadUrl,
       write,
       update,
-      delete: deleteFile
+      delete: deleteDocument,
+      search,
+      attach,
+      detach,
+      upload,
+      uploadInit,
+      uploadFinalize
     }),
-    [list, read, getDownloadUrl, write, update, deleteFile]
+    [
+      list,
+      read,
+      getDownloadUrl,
+      write,
+      update,
+      deleteDocument,
+      search,
+      attach,
+      detach,
+      upload,
+      uploadInit,
+      uploadFinalize
+    ]
   );
 }
+function bytesToHex(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i++) {
+    out += bytes[i].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function useArcheAssets() {
+  const bridge = useBridge();
+  const list = useCallback(
+    async (options) => {
+      return bridge.request("arche_assets_list", {
+        cursor: options?.cursor,
+        limit: options?.limit
+      });
+    },
+    [bridge]
+  );
+  const getUrl = useCallback(
+    async (assetId) => {
+      return bridge.request("arche_assets_get_url", { assetId });
+    },
+    [bridge]
+  );
+  return useMemo2(() => ({ list, getUrl }), [list, getUrl]);
+}
+
+// src/generated/surfaces.ts
+var AUDIO_AUDIO_ISOLATION_SURFACE_KEY = "audio.audio-isolation";
+var useElevenLabsAudioIsolation = () => useSurface(
+  AUDIO_AUDIO_ISOLATION_SURFACE_KEY
+);
+var AUDIO_FORCED_ALIGNMENT_SURFACE_KEY = "audio.forced-alignment";
+var useElevenLabsForcedAlignment = () => useSurface(
+  AUDIO_FORCED_ALIGNMENT_SURFACE_KEY
+);
+var AUDIO_LYRIA_MUSIC_SURFACE_KEY = "audio.lyria-music";
+var useLyriaMusic = () => useSurface(AUDIO_LYRIA_MUSIC_SURFACE_KEY);
+var AUDIO_MUSIC_SURFACE_KEY = "audio.music";
+var useElevenLabsMusic = () => useSurface(AUDIO_MUSIC_SURFACE_KEY);
+var AUDIO_SOUND_EFFECTS_SURFACE_KEY = "audio.sound-effects";
+var useElevenLabsSfx = () => useSurface(AUDIO_SOUND_EFFECTS_SURFACE_KEY);
+var AUDIO_SPEECH_TO_TEXT_SURFACE_KEY = "audio.speech-to-text";
+var useElevenLabsStt = () => useSurface(AUDIO_SPEECH_TO_TEXT_SURFACE_KEY);
+var AUDIO_TTS_SURFACE_KEY = "audio.tts";
+var useElevenLabsTts = () => useSurface(AUDIO_TTS_SURFACE_KEY);
+var AUDIO_VOICE_CHANGER_SURFACE_KEY = "audio.voice-changer";
+var useElevenLabsVoiceChanger = () => useSurface(
+  AUDIO_VOICE_CHANGER_SURFACE_KEY
+);
+var AUDIO_VOICE_DESIGN_SURFACE_KEY = "audio.voice-design";
+var useElevenLabsVoiceDesign = () => useSurface(
+  AUDIO_VOICE_DESIGN_SURFACE_KEY
+);
+
+// src/generated/permissions.ts
+var VALID_PLUGIN_PERMISSIONS = [
+  "assets:read",
+  "data:store",
+  "entities:audio_generate",
+  "entities:image_generate",
+  "entities:invoke",
+  "storage:sandbox",
+  "store:purchase",
+  "theme:read",
+  "user:profile:read",
+  "vault:documents:read",
+  "vault:documents:write"
+];
+function isValidPluginPermission(perm) {
+  return VALID_PLUGIN_PERMISSIONS.includes(perm);
+}
 
 // src/fias.ts
 var fias = {
@@ -2703,28 +2943,51 @@ function getFontPairingById(id) {
   return FONT_PAIRINGS.find((f) => f.id === id) ?? FONT_PAIRINGS[0];
 }
 export {
+  AUDIO_AUDIO_ISOLATION_SURFACE_KEY,
+  AUDIO_FORCED_ALIGNMENT_SURFACE_KEY,
+  AUDIO_LYRIA_MUSIC_SURFACE_KEY,
+  AUDIO_MUSIC_SURFACE_KEY,
+  AUDIO_SOUND_EFFECTS_SURFACE_KEY,
+  AUDIO_SPEECH_TO_TEXT_SURFACE_KEY,
+  AUDIO_TTS_SURFACE_KEY,
+  AUDIO_VOICE_CHANGER_SURFACE_KEY,
+  AUDIO_VOICE_DESIGN_SURFACE_KEY,
   DARK_THEME,
   FONT_PAIRINGS,
   FiasBridge,
   FiasProvider,
   LIGHT_THEME,
   THEME_CATALOG,
-  fetchFileDownloadUrl,
+  VALID_PLUGIN_PERMISSIONS,
+  fetchVaultDocumentDownloadUrl,
   fias,
   getBridge,
   getDefaultTheme,
   getFontPairingById,
   getThemeById,
+  isValidPluginPermission,
   resetBridge,
+  useArcheAssets,
+  useAudioGeneration,
+  useElevenLabsAudioIsolation,
+  useElevenLabsForcedAlignment,
+  useElevenLabsMusic,
+  useElevenLabsSfx,
+  useElevenLabsStt,
+  useElevenLabsTts,
+  useElevenLabsVoiceChanger,
+  useElevenLabsVoiceDesign,
   useEntityInvocation,
   useFiasDataStore,
-  useFiasFiles,
   useFiasNavigation,
   useFiasStorage,
   useFiasStore,
   useFiasTheme,
   useFiasUser,
   useImageGeneration,
+  useLyriaMusic,
   usePersistentState,
-  useStepNavigation
+  useStepNavigation,
+  useSurface,
+  useVaultDocuments
 };