@sparkvault/sdk 1.9.2 → 1.10.0

package/dist/sparkvault.cjs.js

@@ -5102,8 +5102,8 @@ class IdentityRenderer {
  * Implements the Container interface for use with IdentityRenderer.
  */
 const DEFAULT_OPTIONS$1 = {
-    showHeader: true,
-    showCloseButton: true,
+    showHeader: false,
+    showCloseButton: false,
     showFooter: true,
 };
 class InlineContainer {
@@ -5294,6 +5294,36 @@ function onDomReady(callback) {
         callback();
     }
 }
+/**
+ * Execute a callback when document.body is available.
+ * Handles edge cases where body might not exist even after DOMContentLoaded
+ * (e.g., scripts with defer/async loading during parsing).
+ */
+function onBodyReady(callback) {
+    if (document.body) {
+        callback();
+    }
+    else {
+        // Body not yet available - wait for DOMContentLoaded
+        // or poll briefly as a fallback for edge cases
+        const checkBody = () => {
+            if (document.body) {
+                callback();
+            }
+            else {
+                // Rare edge case: poll for body availability
+                window.requestAnimationFrame(checkBody);
+            }
+        };
+        if (document.readyState === 'loading') {
+            document.addEventListener('DOMContentLoaded', checkBody, { once: true });
+        }
+        else {
+            // Document ready but no body yet - poll
+            window.requestAnimationFrame(checkBody);
+        }
+    }
+}
 
 /* global Element */
 /**
@@ -5455,7 +5485,11 @@ class IdentityModule {
                     });
                 });
             });
-            observer.observe(document.body, { childList: true, subtree: true });
+            // Observe document.body for dynamic elements
+            // Use onBodyReady to handle edge cases where body isn't available yet
+            onBodyReady(() => {
+                observer?.observe(document.body, { childList: true, subtree: true });
+            });
         };
         // Defer attachment until DOM is ready
         onDomReady(attachToElements);
@@ -7106,7 +7140,7 @@ class UploadModalContainer {
       <div class="svu-security-badges">
         <span class="svu-tls-badge">TLS 1.3 In Transit</span>
         <span class="svu-tls-badge">Encrypted At Rest</span>
-        <span class="svu-tls-badge">Zero Knowledge</span>
+        <span class="svu-tls-badge">Zero Trust</span>
       </div>
     `;
         sidebar.appendChild(security);
@@ -7172,8 +7206,8 @@ class UploadModalContainer {
  * Implements the UploadContainer interface for use with UploadRenderer.
  */
 const DEFAULT_OPTIONS = {
-    showHeader: true,
-    showCloseButton: true,
+    showHeader: false,
+    showCloseButton: false,
     showFooter: true,
 };
 class UploadInlineContainer {
@@ -7465,7 +7499,7 @@ class UploadInlineContainer {
       <div class="svu-security-badges">
         <span class="svu-tls-badge">TLS 1.3 In Transit</span>
         <span class="svu-tls-badge">Encrypted At Rest</span>
-        <span class="svu-tls-badge">Zero Knowledge</span>
+        <span class="svu-tls-badge">Zero Trust</span>
       </div>
     `;
         sidebar.appendChild(security);
@@ -8116,45 +8150,81 @@ class UploadRenderer {
         }
     }
     async uploadWithTus(file, forgeUrl, ingotId, requestId) {
-        // Simple XHR upload with progress (tus-like behavior)
-        // Timeout: 10 minutes for large file uploads
-        const UPLOAD_TIMEOUT_MS = 10 * 60 * 1000;
-        return new Promise((resolve, reject) => {
-            const xhr = new XMLHttpRequest();
-            xhr.timeout = UPLOAD_TIMEOUT_MS;
-            xhr.upload.onprogress = (e) => {
-                if (e.lengthComputable) {
-                    const progress = Math.round((e.loaded / e.total) * 100);
-                    this.setState({
-                        view: 'uploading',
-                        file,
-                        ingotId,
-                        requestId,
-                        progress,
-                        bytesUploaded: e.loaded,
-                    });
-                    this.callbacks.onProgress?.({
-                        bytesUploaded: e.loaded,
-                        bytesTotal: e.total,
-                        percentage: progress,
-                        phase: 'uploading',
-                    });
-                }
-            };
-            xhr.onload = () => {
-                if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Upload failed with status ${xhr.status}`));
-                }
-            };
-            xhr.onerror = () => reject(new Error('Upload failed'));
-            xhr.ontimeout = () => reject(new Error('Upload timed out'));
-            xhr.open('POST', forgeUrl);
-            xhr.setRequestHeader('Content-Type', file.type || 'application/octet-stream');
-            xhr.send(file);
+        // tus resumable upload protocol v1.0.0
+        // Uploads file in chunks to avoid Cloudflare's 100MB request limit
+        const TUS_VERSION = '1.0.0';
+        const DEFAULT_CHUNK_SIZE = 50 * 1024 * 1024; // 50MB default, server may override
+        // Extract base URL and ISTK from forge URL
+        const url = new URL(forgeUrl);
+        const istk = url.searchParams.get('istk');
+        const baseUrl = `${url.origin}${url.pathname}`;
+        if (!istk) {
+            throw new Error('Missing ISTK in forge URL');
+        }
+        // Step 1: Create tus upload session
+        const createResponse = await fetch(baseUrl, {
+            method: 'POST',
+            headers: {
+                'Tus-Resumable': TUS_VERSION,
+                'Upload-Length': String(file.size),
+                'X-ISTK': istk,
+                'Content-Type': 'application/offset+octet-stream',
+            },
         });
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            throw new Error(`Failed to create upload session: ${createResponse.status} ${errorText}`);
+        }
+        // Get upload location and chunk size from response
+        const location = createResponse.headers.get('Location');
+        const chunkSizeHeader = createResponse.headers.get('X-Chunk-Size');
+        const chunkSize = chunkSizeHeader ? parseInt(chunkSizeHeader, 10) : DEFAULT_CHUNK_SIZE;
+        if (!location) {
+            throw new Error('Server did not return upload location');
+        }
+        // Build full upload URL
+        const uploadUrl = location.startsWith('http') ? location : `${url.origin}${location}`;
+        // Step 2: Upload file in chunks
+        let offset = 0;
+        const totalSize = file.size;
+        while (offset < totalSize) {
+            const end = Math.min(offset + chunkSize, totalSize);
+            const chunk = file.slice(offset, end);
+            // Upload chunk
+            const patchResponse = await fetch(uploadUrl, {
+                method: 'PATCH',
+                headers: {
+                    'Tus-Resumable': TUS_VERSION,
+                    'Upload-Offset': String(offset),
+                    'Content-Type': 'application/offset+octet-stream',
+                },
+                body: chunk,
+            });
+            if (!patchResponse.ok) {
+                const errorText = await patchResponse.text();
+                throw new Error(`Chunk upload failed: ${patchResponse.status} ${errorText}`);
+            }
+            // Update offset from server response
+            const newOffsetHeader = patchResponse.headers.get('Upload-Offset');
+            const newOffset = newOffsetHeader ? parseInt(newOffsetHeader, 10) : end;
+            offset = newOffset;
+            // Update progress
+            const progress = Math.round((offset / totalSize) * 100);
+            this.setState({
+                view: 'uploading',
+                file,
+                ingotId,
+                requestId,
+                progress,
+                bytesUploaded: offset,
+            });
+            this.callbacks.onProgress?.({
+                bytesUploaded: offset,
+                bytesTotal: totalSize,
+                percentage: progress,
+                phase: 'uploading',
+            });
+        }
     }
     async runCeremony(file, ingotId, requestId) {
         for (let i = 0; i < CEREMONY_STEPS.length; i++) {