@leadping/consent 1.0.4 → 1.0.5

package/dist/esm/capture.d.ts

@@ -5,9 +5,14 @@ export declare class ConsentCapture {
     private static active?;
     private readonly browser;
     private readonly buffer;
+    private readonly deadline;
     private transport?;
     /** Resolves when the service session is available and validated. Recording starts before this. */
     readonly ready: Promise<void>;
+    /** Allocated as soon as the session is ready; this does not assert that submission is saved. */
+    get sessionId(): string | undefined;
+    /** The server-selected duration limit, available after ready resolves. */
+    get maxReplaySeconds(): number | undefined;
     private session?;
     private readonly observedDisclosure;
     private disposed;

package/dist/esm/capture.js

@@ -1,6 +1,8 @@
 import { record } from 'rrweb';
 import { EventBuffer } from './event-buffer.js';
 import { CaptureTransport } from './transport.js';
+import { ReplayDeadline } from './replay-deadline.js';
+import { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
 /** One form recording per document, matching rrweb's document-level recorder. */
 export class ConsentCapture {
     options;
@@ -18,9 +20,14 @@ export class ConsentCapture {
         maxTouchPoints: navigator.maxTouchPoints,
     };
     buffer = new EventBuffer();
+    deadline = new ReplayDeadline();
     transport;
     /** Resolves when the service session is available and validated. Recording starts before this. */
     ready;
+    /** Allocated as soon as the session is ready; this does not assert that submission is saved. */
+    get sessionId() { return this.session?.sessionId; }
+    /** The server-selected duration limit, available after ready resolves. */
+    get maxReplaySeconds() { return this.session?.maxReplaySeconds; }
     session;
     observedDisclosure;
     disposed = false;
@@ -52,13 +59,11 @@ export class ConsentCapture {
             if (!/^[0-9a-f-]{36}$/i.test(session.sessionId) || session.form.origin !== location.origin ||
                 session.form.disclosure !== this.observedDisclosure)
                 throw new Error('Form does not match the approved disclosure.');
-            const remaining = Date.parse(session.expiresAt) - Date.now();
-            if (!Number.isFinite(remaining) || remaining <= 0 || remaining > 60 * 60 * 1000)
-                throw new Error('Invalid or expired capture session.');
+            this.deadline.configure(session.expiresAt, session.maxReplaySeconds);
             this.session = session;
             this.transport = new CaptureTransport(url.href.replace(/\/$/, '') + '/consent/sessions/' + session.sessionId, session.uploadToken);
             if (!this.stopped)
-                this.expiry = setTimeout(() => this.fail(new Error('Capture session expired.')), remaining);
+                this.expiry = setTimeout(() => this.fail(new ReplayLimitExceededError()), this.deadline.remainingMilliseconds);
         });
         void this.ready.then(this.backgroundFlush).catch(error => this.fail(error));
         ConsentCapture.active = this;
@@ -115,14 +120,24 @@ export class ConsentCapture {
     async finishCore(recipient) {
         if (this.stopped || this.failure)
             throw this.failure ?? new Error('Recorder is stopped.');
+        try {
+            this.deadline.assertWithinLimit();
+        }
+        catch (error) {
+            this.fail(error);
+            throw error;
+        }
         const observedDisclosure = this.options.disclosure.textContent ?? '';
         if (observedDisclosure !== this.observedDisclosure)
             throw new Error('The disclosure changed during capture. Start a new approved form session.');
         const accepted = this.options.checkbox.checked;
         record.addCustomEvent('leadping.submit', { accepted });
         this.stop();
+        this.options.onProgress?.('uploading');
         await this.flush();
-        await this.transport.put('/submission', JSON.stringify({
+        this.deadline.assertWithinLimit();
+        this.options.onProgress?.('submitting');
+        await this.transport.put(this.options.issueCertificate ? '/submission/certificate' : '/submission', JSON.stringify({
             lastBatchNumber: this.buffer.lastBatchNumber, lastEventNumber: this.buffer.lastEventNumber,
             accepted, observedDisclosure, recipient, browser: this.browser,
         }));
@@ -147,7 +162,7 @@ export class ConsentCapture {
         const batch = this.buffer.seal();
         if (!batch)
             return;
-        // UTF-16 string budget including queued/retrying batches. One in-flight compressed copy is additional.
+        // UTF-16 string budget including queued/retrying batches. Up to three compressed copies are additional.
         if (this.queuedBytes + batch.body.length * 2 > 2 * 1024 * 1024)
             throw new Error('Recording upload backlog exceeded 2 MiB.');
         this.pending.push(batch);
@@ -157,19 +172,25 @@ export class ConsentCapture {
         // Defer so this.sending is assigned before this function can finish.
         await Promise.resolve();
         try {
-            while (this.head < this.pending.length) {
-                const batch = this.pending[this.head];
-                await this.transport.put('/batches/' + batch.number, batch.body);
-                this.queuedBytes -= batch.body.length * 2;
-                this.pending[this.head] = undefined;
-                this.head++;
-                if (this.head === this.pending.length) {
-                    this.pending.length = 0;
-                    this.head = 0;
+            // Batches are immutable and individually numbered. Completion order need not match
+            // recording order; submission still waits for every durable acknowledgment.
+            await Promise.all(Array.from({ length: 3 }, async () => {
+                while (!this.failure && !this.disposed && this.head < this.pending.length) {
+                    const index = this.head++;
+                    const batch = this.pending[index];
+                    await this.transport.put('/batches/' + batch.number, batch.body);
+                    this.queuedBytes -= batch.body.length * 2;
+                    this.pending[index] = undefined;
                 }
+            }));
+            // A concurrent flush may append after the last worker exits but before this continuation.
+            if (this.head === this.pending.length) {
+                this.pending.length = 0;
+                this.head = 0;
             }
         }
         catch (error) {
+            this.transport?.dispose();
             this.fail(error instanceof Error ? error : new Error('Capture upload failed.'));
             throw this.failure;
         }
@@ -177,7 +198,12 @@ export class ConsentCapture {
             this.sending = undefined;
         }
     }
-    consentChanged = () => record.addCustomEvent('leadping.consent', { accepted: this.options.checkbox.checked });
+    consentChanged = () => {
+        record.addCustomEvent('leadping.consent', { accepted: this.options.checkbox.checked });
+        // Start draining while the visitor moves from consenting to submitting.
+        if (this.options.checkbox.checked)
+            this.backgroundFlush();
+    };
     visibilityChanged = () => { if (document.visibilityState === 'hidden')
         this.backgroundFlush(); };
     backgroundFlush = () => { void this.flush().catch(error => this.fail(error)); };

package/dist/esm/embed.d.ts

@@ -1,3 +1,4 @@
 export { ConsentCapture } from './capture.js';
+export { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
 /** Attach the Leadping-hosted capture and submission flow to a form. */
 export declare function attach(script: HTMLScriptElement): Promise<void>;

package/dist/esm/embed.js

@@ -1,6 +1,8 @@
 import { CaptureRejectedError } from './capture-rejected-error.js';
 import { ConsentCapture } from './capture.js';
+import { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
 export { ConsentCapture } from './capture.js';
+export { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
 /** Attach the Leadping-hosted capture and submission flow to a form. */
 export async function attach(script) {
     const domainId = script.dataset.domainId;
@@ -20,7 +22,8 @@ export async function attach(script) {
     let capture;
     let submitted = false;
     const fail = (error) => {
-        status.textContent = 'Unable to complete consent capture. Please reload to start again.';
+        status.textContent = error instanceof ReplayLimitExceededError ? error.message
+            : 'Unable to complete consent capture. Please reload to start again.';
         form.dispatchEvent(new CustomEvent('leadping:error', { detail: error }));
     };
     const origin = new URL(script.dataset.apiUrl ?? 'https://consent.leadping.ai');
@@ -31,6 +34,9 @@ export async function attach(script) {
     if (portal.protocol !== 'https:' || portal.username || portal.password || portal.search || portal.hash || portal.pathname !== '/')
         throw new Error('Leadping requires an HTTPS portal origin.');
     const endpoint = `${origin.origin}/api/consent`;
+    const progress = (stage) => {
+        form.dispatchEvent(new CustomEvent('leadping:progress', { detail: { stage } }));
+    };
     const post = async (path, body) => {
         const attempts = path.endsWith('/sessions') ? 5 : 1;
         for (let attempt = 0; attempt < attempts; attempt++) {
@@ -71,15 +77,11 @@ export async function attach(script) {
             if (typeof value === 'string' && value)
                 recipient[key] = value;
         }
-        let issuingCertificate = false;
         try {
             const consentCapture = await capture.finish(recipient);
-            issuingCertificate = true;
-            const certificate = await (await post('/certificates', consentCapture)).json();
-            if (!/^[0-9a-f-]{36}$/i.test(certificate.certificateId))
-                throw new Error('Invalid certificate response.');
+            const certificate = { certificateId: consentCapture.sessionId };
             const certificateUrl = `${portal.origin}/${certificate.certificateId}`;
-            status.textContent = `Certificate received: ${certificate.certificateId}. `;
+            status.textContent = `Submission saved. Certificate: ${certificate.certificateId}. `;
             const link = document.createElement('a');
             link.href = certificateUrl;
             link.textContent = 'View certificate and replay';
@@ -90,8 +92,8 @@ export async function attach(script) {
         }
         catch (error) {
             fail(error);
-            if (issuingCertificate)
-                status.textContent = 'Certificate issuance could not be confirmed. Please check before starting another recording.';
+            if (!(error instanceof ReplayLimitExceededError))
+                status.textContent = 'Submission could not be confirmed. Keep the certificate ID and check before starting another recording.';
         }
         finally {
             capture.dispose();
@@ -105,12 +107,25 @@ export async function attach(script) {
         const observedDisclosure = disclosure.textContent ?? '';
         capture = new ConsentCapture({ apiUrl: origin.origin + '/api',
             session: async () => (await post(`/domains/${encodeURIComponent(domainId)}/sessions`, { pageUrl, disclosure: observedDisclosure })).json(),
-            form, disclosure, checkbox, onError: fail });
+            form, disclosure, checkbox, issueCertificate: true, onError: fail, onProgress: stage => {
+                status.textContent = stage === 'uploading' ? 'Saving recording…' : 'Saving submission and requesting certificate…';
+                progress(stage);
+            } });
         window.addEventListener('pagehide', () => { capture?.dispose(); }, { once: true });
         await capture.ready;
+        const certificateId = capture.sessionId;
+        const certificateUrl = `${portal.origin}/${certificateId}`;
+        for (const [name, value] of Object.entries({ leadping_certificate_id: certificateId, leadping_certificate_url: certificateUrl })) {
+            const input = document.createElement('input');
+            input.type = 'hidden';
+            input.name = name;
+            input.value = value;
+            form.append(input);
+        }
         if (!submitted)
             status.textContent = '';
-        form.dispatchEvent(new CustomEvent('leadping:ready'));
+        form.dispatchEvent(new CustomEvent('leadping:ready', { detail: { certificateId, certificateUrl,
+                maxReplaySeconds: capture.maxReplaySeconds } }));
     }
     catch (error) {
         capture?.dispose();

package/dist/esm/event-buffer.js

@@ -42,7 +42,7 @@ export class EventBuffer {
     seal() {
         if (this.events.length === 0)
             return;
-        if (this.nextBatch >= 256)
+        if (this.nextBatch >= 1024)
             throw new Error('Recording exceeded the session batch limit.');
         const first = this.nextEvent - this.events.length;
         const body = `{"firstEventNumber":${first},"events":[${this.events.join(',')}]}`;

package/dist/esm/index.d.ts

@@ -1,2 +1,3 @@
 export { ConsentCapture } from './capture.js';
+export { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
 export type { CaptureOptions, CaptureReference, CaptureSession, ConsentForm, Recipient } from './types.js';

package/dist/esm/index.js

@@ -1 +1,2 @@
 export { ConsentCapture } from './capture.js';
+export { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';

package/dist/esm/replay-deadline.d.ts

@@ -0,0 +1,10 @@
+/** Checks elapsed time even when a suspended tab has not run its expiry timer. */
+export declare class ReplayDeadline {
+    private readonly startedAt;
+    private readonly startedTick;
+    private expiresAt;
+    private maximumMs;
+    configure(expiresAt: string, maxReplaySeconds: number): void;
+    get remainingMilliseconds(): number;
+    assertWithinLimit(): void;
+}

package/dist/esm/replay-deadline.js

@@ -0,0 +1,23 @@
+import { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
+/** Checks elapsed time even when a suspended tab has not run its expiry timer. */
+export class ReplayDeadline {
+    startedAt = Date.now();
+    startedTick = performance.now();
+    expiresAt = Infinity;
+    maximumMs = 1800_000;
+    configure(expiresAt, maxReplaySeconds) {
+        const deadline = Date.parse(expiresAt);
+        if (!Number.isFinite(deadline) || !Number.isInteger(maxReplaySeconds) || maxReplaySeconds < 1 || maxReplaySeconds > 1800)
+            throw new Error('Invalid recording time limit.');
+        this.expiresAt = deadline;
+        this.maximumMs = maxReplaySeconds * 1000;
+        this.assertWithinLimit();
+    }
+    get remainingMilliseconds() {
+        return Math.min(this.expiresAt - Date.now(), this.maximumMs - (Date.now() - this.startedAt), this.maximumMs - (performance.now() - this.startedTick));
+    }
+    assertWithinLimit() {
+        if (this.remainingMilliseconds <= 0)
+            throw new ReplayLimitExceededError();
+    }
+}

package/dist/esm/replay-limit-exceeded-error.d.ts

@@ -0,0 +1,5 @@
+/** The recording cannot support this submission because its allotted time has elapsed. */
+export declare class ReplayLimitExceededError extends Error {
+    readonly code = "replay_limit_exceeded";
+    constructor();
+}

package/dist/esm/replay-limit-exceeded-error.js

@@ -0,0 +1,8 @@
+/** The recording cannot support this submission because its allotted time has elapsed. */
+export class ReplayLimitExceededError extends Error {
+    code = 'replay_limit_exceeded';
+    constructor() {
+        super("The recording time limit was reached. This submission wasn't captured. Start a new recording and submit again.");
+        this.name = 'ReplayLimitExceededError';
+    }
+}

package/dist/esm/transport.d.ts

@@ -1,4 +1,4 @@
-/** Serial, bounded retry transport. A resolved request means durable server acknowledgment. */
+/** Bounded retry transport. A resolved request means durable server acknowledgment. */
 export declare class CaptureTransport {
     private readonly baseUrl;
     private readonly token;

package/dist/esm/transport.js

@@ -1,5 +1,6 @@
 import { CaptureRejectedError } from './capture-rejected-error.js';
-/** Serial, bounded retry transport. A resolved request means durable server acknowledgment. */
+import { ReplayLimitExceededError } from './replay-limit-exceeded-error.js';
+/** Bounded retry transport. A resolved request means durable server acknowledgment. */
 export class CaptureTransport {
     baseUrl;
     token;
@@ -26,11 +27,13 @@ export class CaptureTransport {
                 });
                 if (response.ok)
                     return;
+                if (response.status === 410)
+                    throw new ReplayLimitExceededError();
                 if (response.status < 500 && response.status !== 408 && response.status !== 429)
                     throw new CaptureRejectedError(`Capture rejected (${response.status}).`);
             }
             catch (error) {
-                if (error instanceof CaptureRejectedError || this.abort.signal.aborted)
+                if (error instanceof CaptureRejectedError || error instanceof ReplayLimitExceededError || this.abort.signal.aborted)
                     throw error;
             }
             if (attempt === 4)

package/dist/esm/types.d.ts

@@ -12,6 +12,8 @@ export interface CaptureSession {
     sessionId: string;
     uploadToken: string;
     expiresAt: string;
+    /** Maximum elapsed recording time including idle time, supplied by the service. */
+    maxReplaySeconds: number;
     form: ConsentForm;
 }
 export interface Recipient {
@@ -32,8 +34,12 @@ export interface CaptureOptions {
     form: HTMLFormElement;
     disclosure: HTMLElement;
     checkbox: HTMLInputElement;
+    /** For public domain sessions, durably request a certificate with the final submission. */
+    issueCertificate?: boolean;
     /** Called on terminal capture failures; never includes captured values. */
     onError?: (error: Error) => void;
+    /** Submission stages; no captured values or upload credentials are included. */
+    onProgress?: (stage: 'uploading' | 'submitting') => void;
 }
 export interface SealedBatch {
     number: number;

package/dist/leadping-consent.js

@@ -22,6 +22,7 @@ var LeadpingConsent = (() => {
   var embed_exports = {};
   __export(embed_exports, {
     ConsentCapture: () => ConsentCapture,
+    ReplayLimitExceededError: () => ReplayLimitExceededError,
     attach: () => attach
   });
 
@@ -12763,7 +12764,7 @@ var LeadpingConsent = (() => {
     }
     seal() {
       if (this.events.length === 0) return;
-      if (this.nextBatch >= 256) throw new Error("Recording exceeded the session batch limit.");
+      if (this.nextBatch >= 1024) throw new Error("Recording exceeded the session batch limit.");
       const first = this.nextEvent - this.events.length;
       const body = `{"firstEventNumber":${first},"events":[${this.events.join(",")}]}`;
       this.events.length = 0;
@@ -12772,6 +12773,15 @@ var LeadpingConsent = (() => {
     }
   };
 
+  // src/replay-limit-exceeded-error.ts
+  var ReplayLimitExceededError = class extends Error {
+    code = "replay_limit_exceeded";
+    constructor() {
+      super("The recording time limit was reached. This submission wasn't captured. Start a new recording and submit again.");
+      this.name = "ReplayLimitExceededError";
+    }
+  };
+
   // src/transport.ts
   var CaptureTransport = class {
     constructor(baseUrl, token) {
@@ -12802,10 +12812,11 @@ var LeadpingConsent = (() => {
             signal: AbortSignal.any([this.abort.signal, AbortSignal.timeout(15e3)])
           });
           if (response.ok) return;
+          if (response.status === 410) throw new ReplayLimitExceededError();
           if (response.status < 500 && response.status !== 408 && response.status !== 429)
             throw new CaptureRejectedError(`Capture rejected (${response.status}).`);
         } catch (error) {
-          if (error instanceof CaptureRejectedError || this.abort.signal.aborted) throw error;
+          if (error instanceof CaptureRejectedError || error instanceof ReplayLimitExceededError || this.abort.signal.aborted) throw error;
         }
         if (attempt === 4) break;
         await this.delay(Math.min(8e3, 500 * 2 ** attempt) + Math.random() * 250);
@@ -12831,6 +12842,32 @@ var LeadpingConsent = (() => {
     }
   };
 
+  // src/replay-deadline.ts
+  var ReplayDeadline = class {
+    startedAt = Date.now();
+    startedTick = performance.now();
+    expiresAt = Infinity;
+    maximumMs = 18e5;
+    configure(expiresAt, maxReplaySeconds) {
+      const deadline = Date.parse(expiresAt);
+      if (!Number.isFinite(deadline) || !Number.isInteger(maxReplaySeconds) || maxReplaySeconds < 1 || maxReplaySeconds > 1800)
+        throw new Error("Invalid recording time limit.");
+      this.expiresAt = deadline;
+      this.maximumMs = maxReplaySeconds * 1e3;
+      this.assertWithinLimit();
+    }
+    get remainingMilliseconds() {
+      return Math.min(
+        this.expiresAt - Date.now(),
+        this.maximumMs - (Date.now() - this.startedAt),
+        this.maximumMs - (performance.now() - this.startedTick)
+      );
+    }
+    assertWithinLimit() {
+      if (this.remainingMilliseconds <= 0) throw new ReplayLimitExceededError();
+    }
+  };
+
   // src/capture.ts
   var ConsentCapture = class _ConsentCapture {
     constructor(options) {
@@ -12846,12 +12883,10 @@ var LeadpingConsent = (() => {
         if (this.disposed || this.failure) throw this.failure ?? new Error("Recorder is disposed.");
         if (!/^[0-9a-f-]{36}$/i.test(session.sessionId) || session.form.origin !== location.origin || session.form.disclosure !== this.observedDisclosure)
           throw new Error("Form does not match the approved disclosure.");
-        const remaining = Date.parse(session.expiresAt) - Date.now();
-        if (!Number.isFinite(remaining) || remaining <= 0 || remaining > 60 * 60 * 1e3)
-          throw new Error("Invalid or expired capture session.");
+        this.deadline.configure(session.expiresAt, session.maxReplaySeconds);
         this.session = session;
         this.transport = new CaptureTransport(url.href.replace(/\/$/, "") + "/consent/sessions/" + session.sessionId, session.uploadToken);
-        if (!this.stopped) this.expiry = setTimeout(() => this.fail(new Error("Capture session expired.")), remaining);
+        if (!this.stopped) this.expiry = setTimeout(() => this.fail(new ReplayLimitExceededError()), this.deadline.remainingMilliseconds);
       });
       void this.ready.then(this.backgroundFlush).catch((error) => this.fail(error));
       _ConsentCapture.active = this;
@@ -12901,9 +12936,18 @@ var LeadpingConsent = (() => {
       maxTouchPoints: navigator.maxTouchPoints
     };
     buffer = new EventBuffer();
+    deadline = new ReplayDeadline();
     transport;
     /** Resolves when the service session is available and validated. Recording starts before this. */
     ready;
+    /** Allocated as soon as the session is ready; this does not assert that submission is saved. */
+    get sessionId() {
+      return this.session?.sessionId;
+    }
+    /** The server-selected duration limit, available after ready resolves. */
+    get maxReplaySeconds() {
+      return this.session?.maxReplaySeconds;
+    }
     session;
     observedDisclosure;
     disposed = false;
@@ -12940,14 +12984,23 @@ var LeadpingConsent = (() => {
     }
     async finishCore(recipient) {
       if (this.stopped || this.failure) throw this.failure ?? new Error("Recorder is stopped.");
+      try {
+        this.deadline.assertWithinLimit();
+      } catch (error) {
+        this.fail(error);
+        throw error;
+      }
       const observedDisclosure = this.options.disclosure.textContent ?? "";
       if (observedDisclosure !== this.observedDisclosure)
         throw new Error("The disclosure changed during capture. Start a new approved form session.");
       const accepted = this.options.checkbox.checked;
       record.addCustomEvent("leadping.submit", { accepted });
       this.stop();
+      this.options.onProgress?.("uploading");
       await this.flush();
-      await this.transport.put("/submission", JSON.stringify({
+      this.deadline.assertWithinLimit();
+      this.options.onProgress?.("submitting");
+      await this.transport.put(this.options.issueCertificate ? "/submission/certificate" : "/submission", JSON.stringify({
         lastBatchNumber: this.buffer.lastBatchNumber,
         lastEventNumber: this.buffer.lastEventNumber,
         accepted,
@@ -12979,25 +13032,31 @@ var LeadpingConsent = (() => {
     async send() {
       await Promise.resolve();
       try {
-        while (this.head < this.pending.length) {
-          const batch = this.pending[this.head];
-          await this.transport.put("/batches/" + batch.number, batch.body);
-          this.queuedBytes -= batch.body.length * 2;
-          this.pending[this.head] = void 0;
-          this.head++;
-          if (this.head === this.pending.length) {
-            this.pending.length = 0;
-            this.head = 0;
-          }
+        await Promise.all(Array.from({ length: 3 }, async () => {
+          while (!this.failure && !this.disposed && this.head < this.pending.length) {
+            const index2 = this.head++;
+            const batch = this.pending[index2];
+            await this.transport.put("/batches/" + batch.number, batch.body);
+            this.queuedBytes -= batch.body.length * 2;
+            this.pending[index2] = void 0;
+          }
+        }));
+        if (this.head === this.pending.length) {
+          this.pending.length = 0;
+          this.head = 0;
         }
       } catch (error) {
+        this.transport?.dispose();
         this.fail(error instanceof Error ? error : new Error("Capture upload failed."));
         throw this.failure;
       } finally {
         this.sending = void 0;
       }
     }
-    consentChanged = () => record.addCustomEvent("leadping.consent", { accepted: this.options.checkbox.checked });
+    consentChanged = () => {
+      record.addCustomEvent("leadping.consent", { accepted: this.options.checkbox.checked });
+      if (this.options.checkbox.checked) this.backgroundFlush();
+    };
     visibilityChanged = () => {
       if (document.visibilityState === "hidden") this.backgroundFlush();
     };
@@ -13038,7 +13097,7 @@ var LeadpingConsent = (() => {
     let capture;
     let submitted = false;
     const fail = (error) => {
-      status.textContent = "Unable to complete consent capture. Please reload to start again.";
+      status.textContent = error instanceof ReplayLimitExceededError ? error.message : "Unable to complete consent capture. Please reload to start again.";
       form.dispatchEvent(new CustomEvent("leadping:error", { detail: error }));
     };
     const origin = new URL(script2.dataset.apiUrl ?? "https://consent.leadping.ai");
@@ -13048,6 +13107,9 @@ var LeadpingConsent = (() => {
     if (portal.protocol !== "https:" || portal.username || portal.password || portal.search || portal.hash || portal.pathname !== "/")
       throw new Error("Leadping requires an HTTPS portal origin.");
     const endpoint = `${origin.origin}/api/consent`;
+    const progress = (stage) => {
+      form.dispatchEvent(new CustomEvent("leadping:progress", { detail: { stage } }));
+    };
     const post = async (path, body) => {
       const attempts = path.endsWith("/sessions") ? 5 : 1;
       for (let attempt = 0; attempt < attempts; attempt++) {
@@ -13086,14 +13148,11 @@ var LeadpingConsent = (() => {
         const value = values.get(key);
         if (typeof value === "string" && value) recipient[key] = value;
       }
-      let issuingCertificate = false;
       try {
         const consentCapture = await capture.finish(recipient);
-        issuingCertificate = true;
-        const certificate = await (await post("/certificates", consentCapture)).json();
-        if (!/^[0-9a-f-]{36}$/i.test(certificate.certificateId)) throw new Error("Invalid certificate response.");
+        const certificate = { certificateId: consentCapture.sessionId };
         const certificateUrl = `${portal.origin}/${certificate.certificateId}`;
-        status.textContent = `Certificate received: ${certificate.certificateId}. `;
+        status.textContent = `Submission saved. Certificate: ${certificate.certificateId}. `;
         const link = document.createElement("a");
         link.href = certificateUrl;
         link.textContent = "View certificate and replay";
@@ -13103,7 +13162,8 @@ var LeadpingConsent = (() => {
         form.dispatchEvent(new CustomEvent("leadping:success", { detail: { certificateId: certificate.certificateId, certificateUrl } }));
       } catch (error) {
         fail(error);
-        if (issuingCertificate) status.textContent = "Certificate issuance could not be confirmed. Please check before starting another recording.";
+        if (!(error instanceof ReplayLimitExceededError))
+          status.textContent = "Submission could not be confirmed. Keep the certificate ID and check before starting another recording.";
       } finally {
         capture.dispose();
       }
@@ -13120,14 +13180,32 @@ var LeadpingConsent = (() => {
         form,
         disclosure,
         checkbox,
-        onError: fail
+        issueCertificate: true,
+        onError: fail,
+        onProgress: (stage) => {
+          status.textContent = stage === "uploading" ? "Saving recording\u2026" : "Saving submission and requesting certificate\u2026";
+          progress(stage);
+        }
       });
       window.addEventListener("pagehide", () => {
         capture?.dispose();
       }, { once: true });
       await capture.ready;
+      const certificateId = capture.sessionId;
+      const certificateUrl = `${portal.origin}/${certificateId}`;
+      for (const [name, value] of Object.entries({ leadping_certificate_id: certificateId, leadping_certificate_url: certificateUrl })) {
+        const input2 = document.createElement("input");
+        input2.type = "hidden";
+        input2.name = name;
+        input2.value = value;
+        form.append(input2);
+      }
       if (!submitted) status.textContent = "";
-      form.dispatchEvent(new CustomEvent("leadping:ready"));
+      form.dispatchEvent(new CustomEvent("leadping:ready", { detail: {
+        certificateId,
+        certificateUrl,
+        maxReplaySeconds: capture.maxReplaySeconds
+      } }));
     } catch (error) {
       capture?.dispose();
       fail(error);