@sparkvault/sdk 1.9.2 → 1.10.1

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,26 +8150,75 @@ 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;
+        // 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 with progress tracking
+        let offset = 0;
+        const totalSize = file.size;
+        while (offset < totalSize) {
+            const chunkStart = offset;
+            const chunkEnd = Math.min(offset + chunkSize, totalSize);
+            const chunk = file.slice(chunkStart, chunkEnd);
+            // Upload chunk with XHR for progress events
+            const newOffset = await this.uploadChunkWithProgress(uploadUrl, chunk, chunkStart, totalSize, TUS_VERSION, file, ingotId, requestId);
+            offset = newOffset;
+        }
+    }
+    /**
+     * Upload a single chunk using XMLHttpRequest for progress tracking
+     */
+    uploadChunkWithProgress(uploadUrl, chunk, chunkStart, totalSize, tusVersion, file, ingotId, requestId) {
         return new Promise((resolve, reject) => {
             const xhr = new XMLHttpRequest();
-            xhr.timeout = UPLOAD_TIMEOUT_MS;
+            // Track progress within this chunk
             xhr.upload.onprogress = (e) => {
                 if (e.lengthComputable) {
-                    const progress = Math.round((e.loaded / e.total) * 100);
+                    // Calculate total progress: completed chunks + progress within current chunk
+                    const totalUploaded = chunkStart + e.loaded;
+                    const progress = Math.round((totalUploaded / totalSize) * 100);
                     this.setState({
                         view: 'uploading',
                         file,
                         ingotId,
                         requestId,
                         progress,
-                        bytesUploaded: e.loaded,
+                        bytesUploaded: totalUploaded,
                     });
                     this.callbacks.onProgress?.({
-                        bytesUploaded: e.loaded,
-                        bytesTotal: e.total,
+                        bytesUploaded: totalUploaded,
+                        bytesTotal: totalSize,
                         percentage: progress,
                         phase: 'uploading',
                     });
@@ -8143,17 +8226,22 @@ class UploadRenderer {
             };
             xhr.onload = () => {
                 if (xhr.status >= 200 && xhr.status < 300) {
-                    resolve();
+                    // Get new offset from server response
+                    const newOffsetHeader = xhr.getResponseHeader('Upload-Offset');
+                    const newOffset = newOffsetHeader ? parseInt(newOffsetHeader, 10) : chunkStart + chunk.size;
+                    resolve(newOffset);
                 }
                 else {
-                    reject(new Error(`Upload failed with status ${xhr.status}`));
+                    reject(new Error(`Chunk 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);
+            xhr.onerror = () => reject(new Error('Chunk upload failed'));
+            xhr.ontimeout = () => reject(new Error('Chunk upload timed out'));
+            xhr.open('PATCH', uploadUrl);
+            xhr.setRequestHeader('Tus-Resumable', tusVersion);
+            xhr.setRequestHeader('Upload-Offset', String(chunkStart));
+            xhr.setRequestHeader('Content-Type', 'application/offset+octet-stream');
+            xhr.send(chunk);
         });
     }
     async runCeremony(file, ingotId, requestId) {