udp-stencil-component-library 25.18.2-beta.7 → 25.18.2-beta.8

package/dist/esm/udp-forms-renderer.entry.js

@@ -2,7 +2,7 @@ import { r as registerInstance, h, a as getElement } from './index-CaZq3YdB.js';
 import { throttle } from 'lodash';
 import { g as getCurrentTenantId } from './tenantUtils-Basdb1b1.js';
 import { f as fetchLatestForms } from './udp-form-api-utils-vPSYCvIA.js';
-import { b as UdpFormsSubmissionStatusEnum, c as UdpFormsFieldTypeEnum, U as UdpFormsPageIdEnum, a as UdpFormsTypeEnum } from './enums-DHT5wSnX.js';
+import { b as UdpFormsSubmissionStatusEnum, U as UdpFormsPageIdEnum, c as UdpFormsFieldTypeEnum, a as UdpFormsTypeEnum } from './enums-DHT5wSnX.js';
 import { b as buildEmptyCurrentValues } from './utils-kwLwITIE.js';
 import { c as createFormData, m as makeApiCall } from './makeApiCall-B-daVutk.js';
 import { S as SearchBuilder, c as SearchOperators } from './SearchBuilder-CvKqGlUH.js';
@@ -22,67 +22,6 @@ function isFileArray(array) {
     return array.every(item => item instanceof File);
 }
 
-// TODO: This handler needs to be updated with new public form logic.
-// ******* THIS HANDLER IS OUTDATED, AND WILL LIKELY NOT WORK *********
-/**
- * Handles submission for *public* (unauthenticated) forms.
- */
-class PublicFormSubmissionHandler {
-    constructor(formId, formVersion, tenantId) { }
-    async fetchAndPopulateUdpFormSubmissionObj(submission) {
-        return submission;
-    }
-    objectToFormData(obj) {
-        var _a, _b;
-        const files = [];
-        const formObj = {};
-        for (const key in obj) {
-            let value = (_b = (_a = obj[key]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : obj[key];
-            if (isFileArray(value)) {
-                if (value.length > 0) {
-                    files.push(value[0]);
-                    formObj[key] = value[0].name;
-                }
-            }
-            else if (Array.isArray(value)) {
-                formObj[key] = value.map(v => (typeof v === 'string' ? v : v.value)).join(',');
-            }
-            else if (value !== null && value !== undefined && value !== '') {
-                formObj[key] = value;
-            }
-        }
-        return createFormData({
-            formData: JSON.stringify(formObj),
-            formFiles: files[0] || null
-        });
-    }
-    async saveCurrentFormSubmissionState(values, submission) {
-        return submission;
-    }
-    async saveFormSubmissionComments(values, submission) {
-        return submission;
-    }
-    async createNewLinkedFollowUpFormSubmission(submission) {
-        return submission;
-    }
-    async finalizeFormSubmissionState(values, submission) {
-        try {
-            // const formData = this.objectToFormData(values);
-            // await makeApiCall(
-            //   'POST',
-            //   `${ConfigService.productV1ApiUrl}/UdpForm/${this.formId}/${this.formVersion}/submit/public?tenantId=${this.tenantId}`,
-            //   formData,
-            //   true
-            // );
-            return submission;
-        }
-        catch (error) {
-            console.error('Public form submission failed:', error);
-            throw error;
-        }
-    }
-}
-
 class UdpFormSubmission {
     constructor(initialData = {}) {
         this.id = null;
@@ -215,260 +154,138 @@ class UdpFormSubmission {
 }
 
 /**
- * Handles CRUD and submission operations for private UdpFormSubmission records.
+ * Single handler for UdpFormSubmission operations.
+ *
+ * Behavior changes by access mode:
+ * - private: supports draft save and follow-ups; comments are saved via standard draft-save until submitted,
+ *            and via dedicated comment endpoints when submitted or viewed by a non-owner.
+ * - public : no draft save, no follow-ups; submit uses the `/UdpFormSubmission/public` endpoint;
+ *            comments use dedicated comment endpoints once a submission exists.
  */
-class PrivateFormSubmissionHandler {
-    // =============================
-    // Fetch Methods
-    // =============================
-    /**
-     * Fetch and refresh an existing UdpFormSubmission instance.
-     *
-     * Attempts to load the latest server representation of the provided
-     * udpFormSubmission. Uses generic fields (generic1/2/3) when present to
-     * disambiguate records, otherwise falls back to a simple id lookup.
-     *
-     * @param udpFormSubmission - local UdpFormSubmission object to refresh
-     * @returns a new UdpFormSubmission merged with server data, or the original on failure
-     * @throws network or unexpected errors
-     */
-    async fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission) {
+class FormSubmissionHandler {
+    constructor(accessMode) {
+        this.accessMode = accessMode;
+    }
+    async addComment(udpFormSubmission, comment) {
         if (!(udpFormSubmission === null || udpFormSubmission === void 0 ? void 0 : udpFormSubmission.id)) {
-            console.warn('Cannot fetch form submission without an ID.');
-            return udpFormSubmission;
-        }
-        try {
-            const { id, generic1, generic2, generic3 } = udpFormSubmission;
-            let response = null;
-            // Prefer the generics-aware lookup if any generic values are present
-            if (generic1 || generic2 || generic3) {
-                response = await this.getFormSubmissionByIdAndGenerics(id, generic1 || undefined, generic2 || undefined, generic3 || undefined);
-            }
-            else {
-                response = await this.getFormSubmissionById(id);
-            }
-            if (!response) {
-                console.warn('No form submission found for the provided object.');
-                return udpFormSubmission;
-            }
-            return new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
-        }
-        catch (error) {
-            console.error('Error fetching form submission:', error);
-            throw error;
+            throw new Error('Cannot add a comment without a submission ID.');
         }
+        // Backend contract:
+        // - public : POST /UdpFormSubmission/{submissionId}/comments/public
+        // - private: POST /UdpFormSubmission/{submissionId}/comments/private
+        const url = `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${this.accessMode}`;
+        await makeApiCall('POST', url, comment, true);
     }
-    /**
-     * Internal helper — lookup a form submission by its unique id.
-     *
-     * Performs a minimal search (page size 1) for the given id and returns
-     * the first match or null if not found. Logs and returns null on errors.
-     *
-     * @param id - submission id to query
-     * @returns UdpFormSubmission or null
-     */
-    async getFormSubmissionById(id) {
-        var _a;
-        try {
-            const search = new SearchBuilder(1, 1)
-                .addFilter('id', id, SearchOperators.EQUALS);
-            const response = await search.execute('UdpFormSubmission');
-            return ((_a = response === null || response === void 0 ? void 0 : response.pageList) === null || _a === void 0 ? void 0 : _a[0]) || null;
+    async updateComment(udpFormSubmission, args) {
+        if (!(udpFormSubmission === null || udpFormSubmission === void 0 ? void 0 : udpFormSubmission.id)) {
+            throw new Error('Cannot update a comment without a submission ID.');
         }
-        catch (error) {
-            console.error('Error fetching form submission by ID:', error);
-            return null;
+        const { sectionKey, questionKey, commentId, value } = args;
+        // Backend contract: PUT /UdpFormSubmission/{submissionId}/comments/{commentId}
+        // Body: { value, sectionKey, questionKey }
+        const url = `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${commentId}`;
+        await makeApiCall('PUT', url, { value, sectionKey, questionKey }, true);
+    }
+    async deleteComment(udpFormSubmission, args) {
+        if (!(udpFormSubmission === null || udpFormSubmission === void 0 ? void 0 : udpFormSubmission.id)) {
+            throw new Error('Cannot delete a comment without a submission ID.');
         }
+        const { commentId } = args;
+        // Backend contract: DELETE /UdpFormSubmission/{submissionId}/comments/{commentId}
+        const url = `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${commentId}`;
+        await makeApiCall('DELETE', url, null, true);
     }
-    /**
-     * Internal helper — lookup a form submission by id and generic fields.
-     *
-     * Adds optional equality filters for generic1/generic2/generic3 when provided,
-     * then executes a minimal search and returns the first match or null.
-     *
-     * @param id - submission id to query
-     * @param generic1 - optional generic1 value to filter by
-     * @param generic2 - optional generic2 value to filter by
-     * @param generic3 - optional generic3 value to filter by
-     * @returns UdpFormSubmission or null
-     */
-    async getFormSubmissionByIdAndGenerics(id, generic1, generic2, generic3) {
-        var _a;
-        try {
-            const search = new SearchBuilder(1, 1)
-                .addFilter('id', id, SearchOperators.EQUALS);
-            if (generic1) {
-                search.addFilter('generic1', generic1, SearchOperators.EQUALS);
-            }
-            if (generic2) {
-                search.addFilter('generic2', generic2, SearchOperators.EQUALS);
-            }
-            if (generic3) {
-                search.addFilter('generic3', generic3, SearchOperators.EQUALS);
-            }
-            const response = await search.execute('UdpFormSubmission');
-            return ((_a = response === null || response === void 0 ? void 0 : response.pageList) === null || _a === void 0 ? void 0 : _a[0]) || null;
+    async fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission) {
+        if (!(udpFormSubmission === null || udpFormSubmission === void 0 ? void 0 : udpFormSubmission.id)) {
+            console.warn('Cannot fetch form submission without an ID.');
+            return udpFormSubmission;
         }
-        catch (error) {
-            console.error('Error fetching form submission by ID:', error);
-            return null;
+        // Public reads should not leak other users' submissions.
+        if (this.accessMode === 'public') {
+            const response = await this.getFormSubmissionByIdAndUser(udpFormSubmission.id, udpFormSubmission.unityUserId);
+            return response ? new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response)) : udpFormSubmission;
         }
+        // Private: fetch by id.
+        const { id } = udpFormSubmission;
+        const response = await this.getFormSubmissionById(id);
+        return response ? new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response)) : udpFormSubmission;
     }
-    // =============================
-    // Save & Submit Methods
-    // =============================
-    /**
-     * Create a new follow-up form submission that is linked to an existing submission.
-     *
-     * Saves a new UdpFormSubmission in 'in-progress' state without populating field values
-     * (only metadata/links), and returns the created submission object.
-     *
-     * @param udpFormSubmission - template/parent submission to base the new follow-up on
-     * @returns newly created UdpFormSubmission
-     */
     async createNewLinkedFollowUpFormSubmission(udpFormSubmission) {
-        const formData = await this.saveFormDataWithoutValues(udpFormSubmission, UdpFormsSubmissionStatusEnum.InProgress);
-        return formData;
-    }
-    /**
-     * Persist submission metadata (without full field values).
-     *
-     * Converts provided udpFormSubmission into formData excluding field values,
-     * determines whether to POST or PUT based on presence of id, and merges the
-     * server response into a new UdpFormSubmission instance.
-     *
-     * @param udpFormSubmission - the submission to save
-     * @param status - desired status to save (e.g., 'in-progress' or 'submitted')
-     * @returns saved UdpFormSubmission (refetches if server returns empty PUT response)
-     */
-    async saveFormDataWithoutValues(udpFormSubmission, status) {
-        try {
-            const formData = udpFormSubmission.processSubmissionIntoFormDataWithoutValues(status);
-            const { method, url } = this.getApiRequestInfo(udpFormSubmission);
-            const response = await makeApiCall(method, url, formData, true);
-            // PUT returns an empty string; refetch to refresh local data
-            if (response === '') {
-                return await this.fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission);
-            }
-            return new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
-        }
-        catch (error) {
-            console.error('Failed to save form udpFormSubmission:', error);
-            throw error;
+        if (this.accessMode === 'public') {
+            throw new Error('Follow-up form submissions are not supported for public forms.');
         }
+        return this.saveFormDataWithoutValues(udpFormSubmission, UdpFormsSubmissionStatusEnum.InProgress);
     }
-    /**
-     * Save only comment-related fields for a submission.
-     *
-     * Delegates to the lower-level saveCommentsToDB helper to persist comment changes
-     * while preserving existing submission state and metadata.
-     *
-     * @param values - comment values to persist
-     * @param udpFormSubmission - target submission object
-     * @returns updated UdpFormSubmission
-     */
-    async saveFormSubmissionComments(values, udpFormSubmission) {
-        return this.saveCommentsToDB(values, udpFormSubmission);
-    }
-    /**
-     * Save the current state of the form's data as a draft ('in-progress').
-     *
-     * Converts the provided values into the required form payload and persists them.
-     * Determines POST vs PUT automatically and refreshes local object on empty PUT responses.
-     *
-     * @param values - field data to save
-     * @param udpFormSubmission - submission being updated
-     * @returns updated UdpFormSubmission
-     */
     async saveCurrentFormSubmissionState(values, udpFormSubmission) {
+        if (this.accessMode === 'public') {
+            // Public forms do not support draft save / return-later.
+            return udpFormSubmission;
+        }
         return this.saveSubmissionToDB(values, udpFormSubmission, UdpFormsSubmissionStatusEnum.InProgress);
     }
-    /**
-     * Finalize and submit the form (set state to 'submitted').
-     *
-     * Persists the provided values and marks the submission as 'submitted'.
-     *
-     * @param values - final form values to submit
-     * @param udpFormSubmission - submission being finalized
-     * @returns updated UdpFormSubmission
-     */
     async finalizeFormSubmissionState(values, udpFormSubmission) {
         return this.saveSubmissionToDB(values, udpFormSubmission, UdpFormsSubmissionStatusEnum.Submitted);
     }
     // =============================
     // Helpers
     // =============================
-    /**
-     * Determine correct HTTP verb and target URL for saving a UdpFormSubmission.
-     *
-     * Uses productV1ApiUrl from ConfigService and returns POST for new submissions
-     * (no id) or PUT with the resource id for existing submissions.
-     *
-     * @param udpFormSubmission - submission to be saved
-     * @returns object with method ('POST'|'PUT') and full url
-     */
+    async saveFormDataWithoutValues(udpFormSubmission, status) {
+        const formData = udpFormSubmission.processSubmissionIntoFormDataWithoutValues(status);
+        const { method, url } = this.getApiRequestInfo(udpFormSubmission);
+        const response = await makeApiCall(method, url, formData, true);
+        if (response === '') {
+            return await this.fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission);
+        }
+        return new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
+    }
     getApiRequestInfo(udpFormSubmission) {
-        const baseUrl = `${ConfigService.productV1ApiUrl}/UdpFormSubmission`;
+        const baseUrl = `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${this.accessMode}`;
+        // Public mode does not support draft saves or updates; only a single submit (POST /public).
+        // Private mode supports POST (create) and PUT (update).
+        if (this.accessMode === 'public') {
+            return { method: 'POST', url: baseUrl };
+        }
         return udpFormSubmission.id
-            ? { method: 'PUT', url: `${baseUrl}/${udpFormSubmission.id}` }
+            ? { method: 'PUT', url: baseUrl }
             : { method: 'POST', url: baseUrl };
     }
-    /**
-     * Persist form values and metadata to the backend.
-     *
-     * Builds the form payload using udpFormSubmission.processSubmissionIntoFormData,
-     * resolves POST vs PUT using getApiRequestInfo, and returns a merged UdpFormSubmission.
-     * If the server returns an empty string for PUT, the method refetches the record.
-     *
-     * @param values - field values to be saved
-     * @param udpFormSubmission - submission being updated
-     * @param status - status to persist (e.g., 'in-progress' | 'submitted')
-     * @returns updated UdpFormSubmission
-     */
     async saveSubmissionToDB(values, udpFormSubmission, status) {
+        const formData = udpFormSubmission.processSubmissionIntoFormData(values, status);
+        const { method, url } = this.getApiRequestInfo(udpFormSubmission);
+        const response = await makeApiCall(method, url, formData, true);
+        if (response === '') {
+            return await this.fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission);
+        }
+        const updated = new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
+        // IMPORTANT: callers often pass a shared `udpFormSubmission` instance and do not use the return value.
+        // Ensure the original instance gets the new server-assigned id/status when the first save/submit creates it.
+        Object.assign(udpFormSubmission, updated);
+        return updated;
+    }
+    async getFormSubmissionById(id) {
+        var _a;
         try {
-            const formData = udpFormSubmission.processSubmissionIntoFormData(values, status);
-            const { method, url } = this.getApiRequestInfo(udpFormSubmission);
-            const response = await makeApiCall(method, url, formData, true);
-            // PUT returns an empty string; refetch to refresh local data
-            if (response === '') {
-                return await this.fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission);
-            }
-            return new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
+            const search = new SearchBuilder(1, 1).addFilter('id', id, SearchOperators.EQUALS);
+            const response = await search.execute('UdpFormSubmission');
+            return ((_a = response === null || response === void 0 ? void 0 : response.pageList) === null || _a === void 0 ? void 0 : _a[0]) || null;
         }
         catch (error) {
-            console.error('Failed to save form udpFormSubmission:', error);
-            throw error;
+            console.error('Error fetching form submission by ID:', error);
+            return null;
         }
     }
-    /**
-     * Persist only comment changes for an existing submission via PUT.
-     *
-     * Forces a PUT to the specific submission id, builds a form payload containing
-     * the provided comment values, and returns the updated submission. If the API
-     * returns an empty string (PUT shorthand), the method refetches the record.
-     *
-     * @param values - comment fields to persist
-     * @param udpFormSubmission - target submission (must have id)
-     * @returns updated UdpFormSubmission
-     */
-    async saveCommentsToDB(values, udpFormSubmission) {
+    async getFormSubmissionByIdAndUser(id, unityUserId) {
         var _a;
         try {
-            const method = 'PUT';
-            const status = (_a = udpFormSubmission.status) !== null && _a !== void 0 ? _a : UdpFormsSubmissionStatusEnum.Submitted;
-            const url = `${ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}`;
-            const formData = udpFormSubmission.processSubmissionIntoFormData(values, status);
-            const response = await makeApiCall(method, url, formData, true);
-            // PUT returns an empty string; refetch to refresh local data
-            if (response === '') {
-                return await this.fetchAndPopulateUdpFormSubmissionObj(udpFormSubmission);
-            }
-            return new UdpFormSubmission(Object.assign(Object.assign({}, udpFormSubmission), response));
+            const search = new SearchBuilder(1, 1)
+                .addFilter('id', id, SearchOperators.EQUALS)
+                .addFilter('unityUserId', unityUserId, SearchOperators.EQUALS);
+            const response = await search.execute('UdpFormSubmission');
+            return ((_a = response === null || response === void 0 ? void 0 : response.pageList) === null || _a === void 0 ? void 0 : _a[0]) || null;
         }
         catch (error) {
-            console.error('Failed to save form udpFormSubmission:', error);
-            throw error;
+            console.error('Error fetching form submission by ID:', error);
+            return null;
         }
     }
 }
@@ -477,36 +294,28 @@ class PrivateFormSubmissionHandler {
  * Factory for creating form submission handlers.
  */
 class FormSubmissionHandlerFactory {
-    static create(isPublic, userId, formId, version, tenantId) {
-        if (isPublic) {
-            return new PublicFormSubmissionHandler(formId, version, tenantId);
-        }
-        if (!userId) {
-            throw new Error('User ID is required for private forms');
-        }
-        return new PrivateFormSubmissionHandler();
+    static create(isPublic, userId) {
+        return new FormSubmissionHandler(isPublic ? 'public' : 'private');
     }
 }
 
-/**
- * UDP Form handler (new UdpFormSubmission endpoint)
- */
 class UdpFormHandler {
-    constructor(tenantId) {
+    constructor(tenantId, isPublic = false) {
         this.tenantId = tenantId;
+        this.isPublic = isPublic;
     }
-    // =============================
-    // Fetching Form
-    // =============================
-    async getFormByFormId(formId) {
-        const formData = await makeApiCall('GET', `${ConfigService.productV1ApiUrl}/UdpForm/${formId}/describe`);
-        if (formData.styleOverrides && typeof formData.styleOverrides === 'string') {
-            formData.styleOverrides = JSON.parse(formData.styleOverrides);
+    buildDescribeUrl(formId, formVersion) {
+        const base = ConfigService.productV1ApiUrl;
+        if (this.isPublic) {
+            return `${base}/UdpForm/${formId}/${formVersion}/describe/public`;
+        }
+        else {
+            return `${base}/UdpForm/${formId}/${formVersion}/describe`;
         }
-        return formData;
     }
     async getFormByFormIdAndFormVersion(formId, formVersion) {
-        const formData = await makeApiCall('GET', `${ConfigService.productV1ApiUrl}/UdpForm/${formId}/${formVersion}/describe`);
+        const url = this.buildDescribeUrl(formId, formVersion);
+        const formData = await makeApiCall('GET', url);
         if (formData.styleOverrides && typeof formData.styleOverrides === 'string') {
             formData.styleOverrides = JSON.parse(formData.styleOverrides);
         }
@@ -715,6 +524,306 @@ const applyUrlSeedValuesForAll = (dynamicSections, urlContext) => {
     });
     return merged;
 };
+const replaceUrlWithSubmissionId = (submissionId, history) => {
+    // build a URL that preserves the current pathname + hash but replaces the query string
+    const pathname = typeof window !== 'undefined' ? window.location.pathname : `/page/${UdpFormsPageIdEnum.FormRendererPageId}`;
+    const hash = typeof window !== 'undefined' ? window.location.hash : '';
+    const newUrl = `${pathname}?udpf_submissionId=${submissionId}${hash}`;
+    const h = history;
+    // Prefer history.replace when available, handle react-router v6 navigate function, fallback to push or native replaceState
+    if (h) {
+        if (typeof h.replace === 'function') {
+            h.replace(newUrl);
+            return;
+        }
+        if (typeof h.push === 'function') {
+            h.push(newUrl);
+            return;
+        }
+        // react-router v6 exposes a navigate function
+        if (typeof h === 'function') {
+            try {
+                h(newUrl, { replace: true });
+            }
+            catch (_a) {
+                h(newUrl);
+            }
+            return;
+        }
+    }
+    if (typeof window !== 'undefined' && window.history && typeof window.history.replaceState === 'function') {
+        window.history.replaceState({}, '', newUrl);
+    }
+    else if (typeof window !== 'undefined') {
+        window.location.href = newUrl;
+    }
+};
+const enqueueSnackbarSuccess = (message, enqueueSnackbar) => {
+    enqueueSnackbar === null || enqueueSnackbar === void 0 ? void 0 : enqueueSnackbar(message, {
+        variant: 'success',
+        anchorOrigin: { vertical: 'top', horizontal: 'center' },
+    });
+};
+const enqueueSnackbarError = (message, enqueueSnackbar) => {
+    enqueueSnackbar === null || enqueueSnackbar === void 0 ? void 0 : enqueueSnackbar(message, {
+        variant: 'error',
+        anchorOrigin: { vertical: 'top', horizontal: 'center' },
+    });
+};
+
+const getSectionKey = (section) => {
+    return section.isOriginalSection ? section.name : `${section.name}_${section.sectionPositionSuffix}`;
+};
+const safeParseFieldProperties = (fieldProperties) => {
+    if (!fieldProperties)
+        return {};
+    if (typeof fieldProperties === 'object')
+        return fieldProperties;
+    if (typeof fieldProperties !== 'string')
+        return {};
+    try {
+        return JSON.parse(fieldProperties || '{}');
+    }
+    catch (_a) {
+        return {};
+    }
+};
+const computeDuplicateRepeatableSection = (params) => {
+    var _a, _b, _c;
+    const { dynamicSections, values, index } = params;
+    const sectionToClone = dynamicSections[index];
+    if (!sectionToClone)
+        return { nextDynamicSections: dynamicSections, nextValues: values };
+    const cloningSectionName = sectionToClone.name;
+    // Find existing repeat group indices
+    const repeatKeys = findRepeatGroupKeys(cloningSectionName, values);
+    const nextRepeatIndex = repeatKeys.length > 0 ? Math.max(...repeatKeys) + 1 : 2;
+    const clonedSection = Object.assign(Object.assign({}, structuredClone(sectionToClone)), { formQuestions: (sectionToClone.formQuestions || []).map(q => {
+            const newQuestionObj = structuredClone(q);
+            newQuestionObj.questionIdentifierKey = `${cloningSectionName}_${nextRepeatIndex}.${q.name}`;
+            return newQuestionObj;
+        }), isOriginalSection: false, sectionPositionSuffix: nextRepeatIndex });
+    // Find the last index of this section group
+    let insertAtIndex = index;
+    for (let i = index + 1; i < dynamicSections.length; i++) {
+        const s = dynamicSections[i];
+        if (s.name === cloningSectionName)
+            insertAtIndex = i;
+        else
+            break;
+    }
+    const nextDynamicSections = [
+        ...dynamicSections.slice(0, insertAtIndex + 1),
+        clonedSection,
+        ...dynamicSections.slice(insertAtIndex + 1),
+    ];
+    const nextValues = structuredClone(values || {});
+    const newSectionKey = `${cloningSectionName}_${nextRepeatIndex}`;
+    const sourceSectionKey = getSectionKey(sectionToClone);
+    for (const q of clonedSection.formQuestions || []) {
+        if (!nextValues[newSectionKey])
+            nextValues[newSectionKey] = {};
+        let value = '';
+        if (q.fieldTypeId === UdpFormsFieldTypeEnum.Paragraph) {
+            const sourceVal = (_b = (_a = values === null || values === void 0 ? void 0 : values[sourceSectionKey]) === null || _a === void 0 ? void 0 : _a[q.name]) === null || _b === void 0 ? void 0 : _b.value;
+            const props = safeParseFieldProperties(q.fieldProperties);
+            const paragraphDefault = (_c = props === null || props === void 0 ? void 0 : props.paragraphText) !== null && _c !== void 0 ? _c : '';
+            value = sourceVal !== null && sourceVal !== void 0 ? sourceVal : paragraphDefault;
+        }
+        nextValues[newSectionKey][q.name] = { value, comments: [], metadata: {} };
+    }
+    return { nextDynamicSections, nextValues };
+};
+const computeDeleteRepeatableSection = (params) => {
+    const { dynamicSections, values, index } = params;
+    const sectionToDelete = dynamicSections[index];
+    if (!sectionToDelete || sectionToDelete.isOriginalSection) {
+        return { nextDynamicSections: dynamicSections, nextValues: values };
+    }
+    const deleteSectionName = sectionToDelete.name;
+    const deleteSuffix = sectionToDelete.sectionPositionSuffix;
+    const sectionKeyToDelete = `${deleteSectionName}_${deleteSuffix}`;
+    const nextValues = Object.assign({}, (values || {}));
+    delete nextValues[sectionKeyToDelete];
+    const updatedSections = structuredClone(dynamicSections);
+    updatedSections.splice(index, 1);
+    // Shift all later repeatable sections backward by 1
+    updatedSections.forEach(section => {
+        var _a;
+        if (section.name !== deleteSectionName ||
+            section.isOriginalSection ||
+            ((_a = section.sectionPositionSuffix) !== null && _a !== void 0 ? _a : 0) <= (deleteSuffix !== null && deleteSuffix !== void 0 ? deleteSuffix : 0)) {
+            return;
+        }
+        const oldSuffix = section.sectionPositionSuffix;
+        const oldSectionKey = `${deleteSectionName}_${oldSuffix}`;
+        const newSuffix = oldSuffix - 1;
+        const newSectionKey = `${deleteSectionName}_${newSuffix}`;
+        section.sectionPositionSuffix = newSuffix;
+        section.formQuestions = (section.formQuestions || []).map(q => {
+            const newSectionQuestion = structuredClone(q);
+            newSectionQuestion.questionIdentifierKey = `${newSectionKey}.${q.name}`;
+            return newSectionQuestion;
+        });
+        if (nextValues[oldSectionKey]) {
+            nextValues[newSectionKey] = structuredClone(nextValues[oldSectionKey]);
+            delete nextValues[oldSectionKey];
+        }
+    });
+    return { nextDynamicSections: updatedSections, nextValues };
+};
+
+/**
+ * Pure comment CRUD logic.
+ *
+ * - Updates submissionResponseData structure for comments/draftComments.
+ * - Does NOT perform any network calls.
+ * - Returns persistence intent for caller.
+ */
+function applyQuestionCommentCrud(params) {
+    var _a, _b, _c, _d, _e;
+    const { actionType, questionIdentifierKey, commentId, currentSubmissionResponseData, clientUserInfo } = params;
+    const parts = (questionIdentifierKey || '').split('.');
+    const sectionKey = parts[0] || '';
+    const questionKey = parts[1] || '';
+    // Defensive: if malformed key, do nothing.
+    if (!sectionKey || !questionKey) {
+        return {
+            sectionKey,
+            questionKey,
+            nextSubmissionResponseData: currentSubmissionResponseData || {},
+            didMutate: false,
+            shouldPersist: false,
+            persistIntent: 'none',
+            commentId,
+        };
+    }
+    const next = structuredClone(currentSubmissionResponseData || {});
+    // ensure structure exists WITHOUT overwriting existing data
+    if (!next[sectionKey])
+        next[sectionKey] = {};
+    if (!next[sectionKey][questionKey]) {
+        // create defaults but do not clobber any existing saved shape from submissionResponseData
+        next[sectionKey][questionKey] = {
+            value: '',
+            comments: [],
+            draftComments: [],
+            metadata: {},
+        };
+    }
+    else {
+        // ensure arrays/objects exist so later code can safely push/filter
+        next[sectionKey][questionKey].comments = (_a = next[sectionKey][questionKey].comments) !== null && _a !== void 0 ? _a : [];
+        next[sectionKey][questionKey].draftComments = (_b = next[sectionKey][questionKey].draftComments) !== null && _b !== void 0 ? _b : [];
+        next[sectionKey][questionKey].metadata = (_c = next[sectionKey][questionKey].metadata) !== null && _c !== void 0 ? _c : {};
+    }
+    // normalize draftComments to array if needed (back-compat)
+    const maybeDraft = next[sectionKey][questionKey].draftComments;
+    if (maybeDraft && !Array.isArray(maybeDraft)) {
+        next[sectionKey][questionKey].draftComments = [maybeDraft];
+    }
+    else if (!maybeDraft) {
+        next[sectionKey][questionKey].draftComments = [];
+    }
+    const commentsArr = next[sectionKey][questionKey].comments || [];
+    const draftsArr = next[sectionKey][questionKey].draftComments || [];
+    let didMutate = false;
+    switch (actionType) {
+        case 'add': {
+            const newDraft = {
+                value: '',
+                commentId: v4(),
+                isTempComment: true,
+                timestamp: null,
+            };
+            // put new draft first so activeDraft === draftComments[0] matches UX
+            next[sectionKey][questionKey].draftComments = [newDraft, ...draftsArr];
+            didMutate = true;
+            break;
+        }
+        case 'save': {
+            const draftIdx = draftsArr.findIndex((d) => d.commentId === commentId);
+            if (draftIdx === -1) {
+                return {
+                    sectionKey,
+                    questionKey,
+                    nextSubmissionResponseData: next,
+                    didMutate: false,
+                    shouldPersist: false,
+                    persistIntent: 'none',
+                    commentId,
+                };
+            }
+            const draft = draftsArr[draftIdx];
+            const saveTimestamp = draft.timestamp || new Date().toISOString();
+            const savedComment = Object.assign(Object.assign({}, draft), { timestamp: saveTimestamp, editedTimestamp: new Date().toISOString(), userId: clientUserInfo === null || clientUserInfo === void 0 ? void 0 : clientUserInfo.id, userDisplayName: clientUserInfo === null || clientUserInfo === void 0 ? void 0 : clientUserInfo.displayName, isDraftComment: false });
+            const existingIdx = commentsArr.findIndex((c) => c.commentId === commentId);
+            if (existingIdx !== -1) {
+                const newComments = [...commentsArr];
+                newComments[existingIdx] = Object.assign({}, savedComment);
+                next[sectionKey][questionKey].comments = newComments;
+            }
+            else {
+                next[sectionKey][questionKey].comments = [...commentsArr, savedComment];
+            }
+            next[sectionKey][questionKey].draftComments = draftsArr.filter((d) => d.commentId !== commentId);
+            didMutate = true;
+            break;
+        }
+        case 'edit': {
+            const saved = commentsArr.find((c) => c.commentId === commentId);
+            if (!saved) {
+                return {
+                    sectionKey,
+                    questionKey,
+                    nextSubmissionResponseData: next,
+                    didMutate: false,
+                    shouldPersist: false,
+                    persistIntent: 'none',
+                    commentId,
+                };
+            }
+            const draftFromSaved = Object.assign(Object.assign({}, saved), { isDraftComment: true, timestamp: null });
+            next[sectionKey][questionKey].draftComments = [draftFromSaved, ...draftsArr];
+            next[sectionKey][questionKey].comments = commentsArr;
+            didMutate = true;
+            break;
+        }
+        case 'delete': {
+            next[sectionKey][questionKey].comments = commentsArr.map((c) => {
+                if (c.commentId === commentId) {
+                    return Object.assign(Object.assign({}, c), { isDeleted: true, value: '', editedTimestamp: new Date().toISOString() });
+                }
+                return c;
+            });
+            didMutate = true;
+            break;
+        }
+        case 'editClose': {
+            next[sectionKey][questionKey].draftComments = draftsArr.filter((d) => d.commentId !== commentId);
+            didMutate = true;
+            break;
+        }
+    }
+    const shouldPersist = actionType === 'save' || actionType === 'delete';
+    // For the dedicated comments API we only ever need the saved comment value.
+    let valueToPersist;
+    if (actionType === 'save') {
+        const saved = (((_e = (_d = next === null || next === void 0 ? void 0 : next[sectionKey]) === null || _d === void 0 ? void 0 : _d[questionKey]) === null || _e === void 0 ? void 0 : _e.comments) || []).find((c) => c.commentId === commentId);
+        valueToPersist = saved === null || saved === void 0 ? void 0 : saved.value;
+    }
+    return {
+        sectionKey,
+        questionKey,
+        nextSubmissionResponseData: next,
+        didMutate,
+        shouldPersist,
+        // Caller decides if this becomes public-add vs private-update.
+        persistIntent: 'none',
+        commentId,
+        valueToPersist,
+    };
+}
 
 const UdpFormsRenderer = class {
     constructor(hostRef) {
@@ -723,17 +832,14 @@ const UdpFormsRenderer = class {
         this.autoSaveDelay = 2000; // Debounce delay for auto-save in milliseconds (currently disabled)
         this.urlContext = {}; // additional context from URL if needed, eg. generic1, gernic2, generic3, or any initial prepopulated values for form inputs. eg section1.question1 = 'some value'
         this.currentValues = {}; // values of the current form state
-        this.formInputSeedValues = {}; // support for a initial set of values to seed the form with
         this.submitSuccessful = false;
         this.isLoading = false;
         this.isSaving = false;
         this.isSubmitted = false;
-        this.saveErrorMessage = null;
         this.dynamicSections = [];
         this.isUpdatingSections = false;
         this.reRenderKey = 0;
-        this.isFormDirty = false;
-        this.isUserUpdatedSections = false;
+        this.hasUnsavedChanges = false;
         this.sideSheetFollowUpFormsList = []; // used for follow up forms. 
         this.followUpSideSheetTotalItems = 0; // used for follow up forms. 
         this.isFollowUpFormsSideSheetOpen = false; // used for follow up forms.
@@ -753,9 +859,19 @@ const UdpFormsRenderer = class {
         };
         this.followUpParentSectionKey = ''; // used for follow up forms.
         this.followUpParentQuestionKey = ''; // used for follow up forms.
+        // Feature flags for public mode. Keep capabilities in the handlers,
+        // but disable UX / automatic flows for now.
+        this.publicFeatures = {
+            allowDraftSave: false, // public cannot save and return later
+            allowComments: true, // public can add comments locally; persistence handled by backend rules
+            allowFollowUpForms: false, // public does not support follow-up forms
+        };
         this.handleLaunchFollowUpFormSideSheet = async (e) => {
             try {
-                await this.performBackgroundSaveAndUpdateLocalSubmissionState(this.udpFormSubmission.data.submissionResponseData);
+                // Public forms do not support follow-up forms.
+                if (this.isPublic) {
+                    return;
+                }
                 this.followUpParentSectionKey = e.detail.sectionKey;
                 this.followUpParentQuestionKey = e.detail.questionKey;
                 await this.loadFollowUpForms(this.followUpParentSectionKey, this.followUpParentQuestionKey);
@@ -774,75 +890,20 @@ const UdpFormsRenderer = class {
             this.isUpdatingSections = true;
             this.isLoading = true;
             try {
-                const sectionToClone = this.dynamicSections[index];
-                if (!sectionToClone)
-                    return;
-                const cloningSectionName = sectionToClone.name;
-                // Find existing repeat group indices
-                const repeatKeys = findRepeatGroupKeys(cloningSectionName, this.currentValues);
-                const nextRepeatIndex = repeatKeys.length > 0 ? Math.max(...repeatKeys) + 1 : 2;
-                const clonedSection = Object.assign(Object.assign({}, structuredClone(sectionToClone)), { formQuestions: sectionToClone.formQuestions.map(q => {
-                        const newQuestionObj = structuredClone(q);
-                        newQuestionObj.questionIdentifierKey = `${cloningSectionName}_${nextRepeatIndex}.${q.name}`;
-                        return newQuestionObj;
-                    }), isOriginalSection: false, sectionPositionSuffix: nextRepeatIndex });
-                // Find the last index of this section group
-                let insertAtIndex = index;
-                for (let i = index + 1; i < this.dynamicSections.length; i++) {
-                    const s = this.dynamicSections[i];
-                    if (s.name === cloningSectionName) {
-                        insertAtIndex = i;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                // Insert after the last repeat of the section group
-                this.dynamicSections = [
-                    ...this.dynamicSections.slice(0, insertAtIndex + 1),
-                    clonedSection,
-                    ...this.dynamicSections.slice(insertAtIndex + 1),
-                ];
-                // Create new initial values structure
-                const newCurrentValues = structuredClone(this.udpFormSubmission.data.submissionResponseData);
-                clonedSection.formQuestions.forEach(q => {
-                    var _a, _b, _c, _d;
-                    const newSectionNameWithSuffix = `${cloningSectionName}_${nextRepeatIndex}`;
-                    const newQuestionName = q.name;
-                    if (!newCurrentValues[newSectionNameWithSuffix]) {
-                        newCurrentValues[newSectionNameWithSuffix] = {};
-                    }
-                    // Preserve only Paragraph values from the source section; clear others
-                    let value = '';
-                    if (q.fieldTypeId === UdpFormsFieldTypeEnum.Paragraph) {
-                        // Determine source section key (the section being duplicated)
-                        const sourceSectionKey = sectionToClone.isOriginalSection
-                            ? cloningSectionName
-                            : `${cloningSectionName}_${sectionToClone.sectionPositionSuffix}`;
-                        const sourceVal = (_c = (_b = (_a = this.udpFormSubmission.data.submissionResponseData) === null || _a === void 0 ? void 0 : _a[sourceSectionKey]) === null || _b === void 0 ? void 0 : _b[newQuestionName]) === null || _c === void 0 ? void 0 : _c.value;
-                        let fieldProps = q === null || q === void 0 ? void 0 : q.fieldProperties;
-                        if (typeof fieldProps === 'string') {
-                            try {
-                                fieldProps = JSON.parse(fieldProps || '{}');
-                            }
-                            catch (_e) {
-                                fieldProps = {};
-                            }
-                        }
-                        const paragraphDefault = (_d = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.paragraphText) !== null && _d !== void 0 ? _d : '';
-                        value = sourceVal !== null && sourceVal !== void 0 ? sourceVal : paragraphDefault;
-                    }
-                    newCurrentValues[newSectionNameWithSuffix][newQuestionName] = { value, comments: [], metadata: {} };
+                const { nextDynamicSections, nextValues } = computeDuplicateRepeatableSection({
+                    dynamicSections: this.dynamicSections,
+                    values: structuredClone(this.udpFormSubmission.data.submissionResponseData || {}),
+                    index,
                 });
-                // This will trigger a complete form re-render
-                this.currentValues = Object.assign({}, newCurrentValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
+                this.dynamicSections = nextDynamicSections;
+                this.currentValues = Object.assign({}, nextValues);
+                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, nextValues);
                 this.triggerFormRerender();
             }
             finally {
                 this.isUpdatingSections = false;
                 this.isLoading = false;
-                this.isUserUpdatedSections = true;
+                this.hasUnsavedChanges = true;
             }
         };
         /**
@@ -857,137 +918,90 @@ const UdpFormsRenderer = class {
             this.isUpdatingSections = true;
             this.isLoading = true;
             try {
-                const deleteSectionName = sectionToDelete.name;
-                const deleteSuffix = sectionToDelete.sectionPositionSuffix;
-                const sectionKeyToDelete = `${deleteSectionName}_${deleteSuffix}`;
-                const newCurrentValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
-                delete newCurrentValues[sectionKeyToDelete];
-                // Remove the section from dynamicSections
-                const updatedSections = structuredClone(this.dynamicSections);
-                updatedSections.splice(index, 1);
-                // Shift all later repeatable sections backward by 1
-                updatedSections.forEach(section => {
-                    if (section.name !== deleteSectionName ||
-                        section.isOriginalSection ||
-                        section.sectionPositionSuffix <= deleteSuffix) {
-                        return;
-                    }
-                    const oldSuffix = section.sectionPositionSuffix;
-                    const oldSectionKey = `${deleteSectionName}_${oldSuffix}`;
-                    const newSuffix = oldSuffix - 1;
-                    const newSectionKey = `${deleteSectionName}_${newSuffix}`;
-                    // Update suffix
-                    section.sectionPositionSuffix = newSuffix;
-                    // Update questionIdentifierKeys
-                    section.formQuestions = section.formQuestions.map(q => {
-                        const newSectionQuestion = structuredClone(q);
-                        newSectionQuestion.questionIdentifierKey = `${newSectionKey}.${q.name}`;
-                        return newSectionQuestion;
-                    });
-                    // Move data in initial values
-                    if (newCurrentValues[oldSectionKey]) {
-                        newCurrentValues[newSectionKey] = structuredClone(newCurrentValues[oldSectionKey]);
-                        delete newCurrentValues[oldSectionKey];
-                    }
+                const { nextDynamicSections, nextValues } = computeDeleteRepeatableSection({
+                    dynamicSections: this.dynamicSections,
+                    values: Object.assign({}, (this.udpFormSubmission.data.submissionResponseData || {})),
+                    index,
                 });
-                this.dynamicSections = updatedSections;
-                this.currentValues = Object.assign({}, newCurrentValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
+                this.dynamicSections = nextDynamicSections;
+                this.currentValues = Object.assign({}, nextValues);
+                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, nextValues);
                 this.triggerFormRerender();
             }
             finally {
                 this.isUpdatingSections = false;
                 this.isLoading = false;
-                this.isUserUpdatedSections = true;
+                this.hasUnsavedChanges = true;
             }
         };
         /**
          * Auto save (background save)
          */
         this.performBackgroundSaveAndUpdateLocalSubmissionState = async (values) => {
-            var _a;
-            this.saveErrorMessage = null;
+            return this.performBackgroundSaveAndUpdateLocalSubmissionStateInternal(values);
+        };
+        this.performBackgroundSaveAndUpdateLocalSubmissionStateInternal = async (values, opts) => {
+            var _a, _b;
+            const allowUrlReplace = (_a = opts === null || opts === void 0 ? void 0 : opts.allowUrlReplace) !== null && _a !== void 0 ? _a : !this.isPublic;
+            const forceCreateDraftIfMissingId = (_b = opts === null || opts === void 0 ? void 0 : opts.forceCreateDraftIfMissingId) !== null && _b !== void 0 ? _b : false;
+            // Public mode: disable draft save flows by default
+            if (this.isPublic && !this.publicFeatures.allowDraftSave && !forceCreateDraftIfMissingId) {
+                return;
+            }
             try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.currentValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
-                if (!new URLSearchParams(window.location.search).has('udpf_submissionId')) {
+                await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
+                await this.refreshSubmissionAndSyncState();
+                if (allowUrlReplace && !new URLSearchParams(window.location.search).has('udpf_submissionId')) {
                     // replace the current entry's query string with udpf_submissionId without needing to know the path
-                    this.replaceUrlWithSubmissionId(updatedUdpFormSubmission.id);
+                    replaceUrlWithSubmissionId(this.udpFormSubmission.id, this.history);
                 }
             }
             catch (error) {
-                this.saveErrorMessage = 'Failed to save form data';
             }
             finally {
                 this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
+                this.hasUnsavedChanges = false;
             }
         };
+        this.refreshSubmissionAndSyncState = async () => {
+            var _a, _b;
+            if (!((_a = this.udpFormSubmission) === null || _a === void 0 ? void 0 : _a.id))
+                return;
+            const updated = await this.formSubmissionHandler.fetchAndPopulateUdpFormSubmissionObj(this.udpFormSubmission);
+            this.udpFormSubmission = updated;
+            this.currentValues = Object.assign({}, (((_b = updated.data) === null || _b === void 0 ? void 0 : _b.submissionResponseData) || {}));
+            this.isSubmitted = updated.status === UdpFormsSubmissionStatusEnum.Submitted;
+        };
         /**
-         * Handle the user saving or deleting a comment
+         * Handle the user saving or deleting a comment (pre-submit, private forms only)
          */
-        this.handleCommmentUpdate = async (values) => {
-            var _a;
-            this.isSaving = true;
-            this.saveErrorMessage = null;
-            try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveFormSubmissionComments(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.currentValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
-                this.enqueueSnackbar('Saved sucessfully.', {
-                    variant: 'success',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-            }
-            catch (error) {
-                this.enqueueSnackbar('There was an error saving.', {
-                    variant: 'error',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-            }
-            finally {
-                this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
-            }
-        };
+        // NOTE: comment saves for non-submitted owner flows are now handled by the standard
+        // draft save path (manual/background save). Dedicated comment endpoints are used
+        // only for:
+        // 1) submitted submissions, OR
+        // 2) non-owner viewers adding/updating/deleting comments.
         /**
-         * Manual save function - debounced to 5 seconds
+         * Manual save function - debounced to 5 seconds (private forms only)
          */
         this.handleManualSave = async (values) => {
-            // Only save if handler supports it and user is authenticated
-            // if (!this.formSubmissionHandler.supportsAutoSave() || !this.userId || !this.formSubmissionHandler.saveCurrentFormSubmissionState) {
-            //   return;
-            // }
-            var _a;
+            if (this.isPublic && !this.publicFeatures.allowDraftSave)
+                return;
             this.isSaving = true;
-            this.saveErrorMessage = null;
             try {
-                const updatedUdpFormSubmission = await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
-                this.udpFormSubmission = updatedUdpFormSubmission;
-                this.currentValues = Object.assign({}, (((_a = updatedUdpFormSubmission.data) === null || _a === void 0 ? void 0 : _a.submissionResponseData) || {}));
+                await this.formSubmissionHandler.saveCurrentFormSubmissionState(values, this.udpFormSubmission);
+                await this.refreshSubmissionAndSyncState();
                 if (!new URLSearchParams(window.location.search).has('udpf_submissionId')) {
                     // replace the current entry's query string with udpf_submissionId without needing to know the path
-                    this.replaceUrlWithSubmissionId(updatedUdpFormSubmission.id);
+                    replaceUrlWithSubmissionId(this.udpFormSubmission.id, this.history);
                 }
-                this.enqueueSnackbar('Form saved successfully.', {
-                    variant: 'success',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
+                enqueueSnackbarSuccess('Form saved successfully.', this.enqueueSnackbar);
             }
             catch (error) {
-                this.enqueueSnackbar('There was an error saving this form', {
-                    variant: 'error',
-                    anchorOrigin: { vertical: 'top', horizontal: 'center' },
-                });
-                this.saveErrorMessage = 'Failed to save form data';
+                enqueueSnackbarError('There was an error saving this form', this.enqueueSnackbar);
             }
             finally {
                 this.isSaving = false;
-                this.isUserUpdatedSections = false;
-                this.isFormDirty = false;
+                this.hasUnsavedChanges = false;
             }
         };
         this.handleFormChange = (values) => {
@@ -1054,7 +1068,9 @@ const UdpFormsRenderer = class {
             // Listen for launchFollowUpFormSideSheet event from udp-question
             this.el.addEventListener('launchFollowUpFormSideSheet', (e) => this.handleLaunchFollowUpFormSideSheet(e));
             this.el.addEventListener('formDirtyChange', (e) => {
-                this.isFormDirty = e.detail;
+                // Preserve any previously-detected unsaved changes (e.g. repeatable section add/delete)
+                // so a later false emission doesn't hide the save icon.
+                this.hasUnsavedChanges = this.hasUnsavedChanges || e.detail;
             });
         }
     }
@@ -1063,17 +1079,24 @@ const UdpFormsRenderer = class {
         this.isLoading = true;
         try {
             // Get client user info if available
-            const user = (_a = this.getUserCallback) === null || _a === void 0 ? void 0 : _a.call(this);
-            if (user) {
-                this.clientUserInfo.id = user.id || null;
-                this.clientUserInfo.displayName = user.name || null;
-                this.clientUserInfo.email = user.email || null;
+            if (this.isPublic) {
+                this.clientUserInfo.id = '00000000-0000-0000-0000-000000000001';
+                this.clientUserInfo.displayName = 'Anonymous';
+            }
+            else {
+                const user = (_a = this.getUserCallback) === null || _a === void 0 ? void 0 : _a.call(this);
+                if (user) {
+                    this.clientUserInfo.id = user.id || null;
+                    this.clientUserInfo.displayName = user.name || null;
+                    this.clientUserInfo.email = user.email || null;
+                }
             }
             this.formSubmissionHandler = FormSubmissionHandlerFactory.create(this.isPublic, this.clientUserInfo.id);
             this.udpFormSubmission = new UdpFormSubmission({ id: this.submissionId, formId: this.formId, formVersion: this.version, unityUserId: this.clientUserInfo.id, generic1: this.urlContext.generic1, generic2: this.urlContext.generic2, generic3: this.urlContext.generic3 });
             // fetch existing submission from Udp.FormSubmission if submissionId is provided 
             // take exisitng object, and populate with db values, and return new obj with updated values
             if (this.submissionId) {
+                // Public users should not open private forms; we rely on backend auth to block.
                 this.udpFormSubmission = await this.formSubmissionHandler.fetchAndPopulateUdpFormSubmissionObj(this.udpFormSubmission);
             }
             // get the master form from Udp.Form
@@ -1132,157 +1155,117 @@ const UdpFormsRenderer = class {
     async handleSubmit(values) {
         this.isLoading = true;
         try {
-            this.udpFormSubmission = await this.formSubmissionHandler.finalizeFormSubmissionState(values, this.udpFormSubmission);
+            await this.formSubmissionHandler.finalizeFormSubmissionState(values, this.udpFormSubmission);
+            await this.refreshSubmissionAndSyncState();
             this.submitSuccessful = true;
         }
         catch (error) {
-            this.enqueueSnackbar('There was an error submitting this form', {
-                variant: 'error',
-                anchorOrigin: { vertical: 'top', horizontal: 'center' },
-            });
+            enqueueSnackbarError('There was an error submitting this form', this.enqueueSnackbar);
             throw error;
         }
         finally {
             this.isLoading = false;
         }
     }
-    replaceUrlWithSubmissionId(submissionId) {
-        // build a URL that preserves the current pathname + hash but replaces the query string
-        const pathname = typeof window !== 'undefined' ? window.location.pathname : `/page/${UdpFormsPageIdEnum.FormRendererPageId}`;
-        const hash = typeof window !== 'undefined' ? window.location.hash : '';
-        const newUrl = `${pathname}?udpf_submissionId=${submissionId}${hash}`;
-        const h = this.history;
-        // Prefer history.replace when available, handle react-router v6 navigate function, fallback to push or native replaceState
-        if (h) {
-            if (typeof h.replace === 'function') {
-                h.replace(newUrl);
-                return;
-            }
-            if (typeof h.push === 'function') {
-                h.push(newUrl);
-                return;
-            }
-            // react-router v6 exposes a navigate function
-            if (typeof h === 'function') {
-                try {
-                    h(newUrl, { replace: true });
-                }
-                catch (_a) {
-                    h(newUrl);
-                }
-                return;
-            }
-        }
-        if (typeof window !== 'undefined' && window.history && typeof window.history.replaceState === 'function') {
-            window.history.replaceState({}, '', newUrl);
-        }
-        else if (typeof window !== 'undefined') {
-            window.location.href = newUrl;
-        }
-    }
     async handleQuestionCommentLiveCRUD(e) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
+        if (this.isPublic && !this.publicFeatures.allowComments)
+            return;
         try {
             const { type, questionIdentifierKey, commentId } = e.detail;
-            const [sectionName, questionName] = questionIdentifierKey.split('.');
-            let newCurrentValues = structuredClone(this.udpFormSubmission.data.submissionResponseData || {});
-            // ensure structure exists WITHOUT overwriting existing data
-            if (!newCurrentValues[sectionName])
-                newCurrentValues[sectionName] = {};
-            if (!newCurrentValues[sectionName][questionName]) {
-                // create defaults but do not clobber any existing saved shape from submissionResponseData
-                newCurrentValues[sectionName][questionName] = {
-                    value: '',
-                    comments: [],
-                    draftComments: [],
-                    metadata: {},
-                };
-            }
-            else {
-                // ensure arrays/objects exist so later code can safely push/filter
-                newCurrentValues[sectionName][questionName].comments = (_a = newCurrentValues[sectionName][questionName].comments) !== null && _a !== void 0 ? _a : [];
-                newCurrentValues[sectionName][questionName].draftComments = (_b = newCurrentValues[sectionName][questionName].draftComments) !== null && _b !== void 0 ? _b : [];
-                newCurrentValues[sectionName][questionName].metadata = (_c = newCurrentValues[sectionName][questionName].metadata) !== null && _c !== void 0 ? _c : {};
-            }
-            // normalize draftComments to array if needed (back-compat)
-            const maybeDraft = newCurrentValues[sectionName][questionName].draftComments;
-            if (maybeDraft && !Array.isArray(maybeDraft)) {
-                newCurrentValues[sectionName][questionName].draftComments = [maybeDraft];
-            }
-            else if (!maybeDraft) {
-                newCurrentValues[sectionName][questionName].draftComments = [];
+            const result = applyQuestionCommentCrud({
+                actionType: type,
+                questionIdentifierKey,
+                commentId,
+                currentSubmissionResponseData: this.udpFormSubmission.data.submissionResponseData || {},
+                clientUserInfo: this.clientUserInfo,
+            });
+            const newCurrentValues = result.nextSubmissionResponseData;
+            // keep submission state in sync
+            this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
+            // Edit-ish actions are UI-only (open/close draft editor). They must update currentValues
+            // even though they don't persist.
+            if (type === 'edit' || type === 'editClose' || type === 'add') {
+                this.currentValues = Object.assign({}, newCurrentValues);
             }
-            const commentsArr = newCurrentValues[sectionName][questionName].comments || [];
-            const draftsArr = newCurrentValues[sectionName][questionName].draftComments || [];
-            switch (type) {
-                case 'add': {
-                    const newDraft = {
-                        value: '',
-                        commentId: v4(),
-                        isTempComment: true,
-                        timestamp: null,
-                    };
-                    // put new draft first so activeDraft === draftComments[0] matches UX
-                    newCurrentValues[sectionName][questionName].draftComments = [newDraft, ...draftsArr];
-                    break;
-                }
-                case 'save': {
-                    // find draft by id
-                    const draftIdx = draftsArr.findIndex(d => d.commentId === commentId);
-                    if (draftIdx === -1)
-                        return;
-                    const draft = draftsArr[draftIdx];
-                    const saveTimestamp = draft.timestamp || new Date().toISOString();
-                    const savedComment = Object.assign(Object.assign({}, draft), { timestamp: saveTimestamp, editedTimestamp: new Date().toISOString(), userId: this.clientUserInfo.id, userDisplayName: this.clientUserInfo.displayName, isDraftComment: false });
-                    // If a saved comment with same id exists, replace it. Otherwise append.
-                    const existingIdx = commentsArr.findIndex(c => c.commentId === commentId);
-                    if (existingIdx !== -1) {
-                        const newComments = [...commentsArr];
-                        newComments[existingIdx] = Object.assign({}, savedComment);
-                        newCurrentValues[sectionName][questionName].comments = newComments;
+            // if it's a save or delete action, persist immediately
+            if (result.shouldPersist) {
+                const submissionIsSubmitted = ((_a = this.udpFormSubmission) === null || _a === void 0 ? void 0 : _a.status) === UdpFormsSubmissionStatusEnum.Submitted;
+                const submissionIsOwnedByCurrentUser = ((_b = this.udpFormSubmission) === null || _b === void 0 ? void 0 : _b.unityUserId) === this.clientUserInfo.id;
+                // Detect whether this save is updating an existing saved comment vs creating a new one.
+                // IMPORTANT: check against the *previous* persisted state (before applyQuestionCommentCrud),
+                // because once we apply 'save' locally the comment will exist locally even if it's new.
+                const existingSavedComment = (((_e = (_d = (_c = ((this.currentValues || {}))) === null || _c === void 0 ? void 0 : _c[result.sectionKey]) === null || _d === void 0 ? void 0 : _d[result.questionKey]) === null || _e === void 0 ? void 0 : _e.comments) || [])
+                    .find((c) => (c === null || c === void 0 ? void 0 : c.commentId) === result.commentId && !(c === null || c === void 0 ? void 0 : c.isDeleted));
+                // Use dedicated comment APIs in 2 scenarios:
+                // 1) Once submitted (public+private) to avoid overwriting submission data.
+                // 2) When viewed by a non-owner (read-only mode), since they can't save the whole submission.
+                if (submissionIsSubmitted || !submissionIsOwnedByCurrentUser) {
+                    if (!((_f = this.udpFormSubmission) === null || _f === void 0 ? void 0 : _f.id)) {
+                        // can't persist without an ID; keep local only
+                        this.currentValues = Object.assign({}, newCurrentValues);
                     }
-                    else {
-                        newCurrentValues[sectionName][questionName].comments = [...commentsArr, savedComment];
+                    else if (type === 'save') {
+                        const valueToPersist = result.valueToPersist;
+                        if (valueToPersist) {
+                            try {
+                                // If this comment already exists, update it; otherwise add it.
+                                if (existingSavedComment) {
+                                    await this.formSubmissionHandler.updateComment(this.udpFormSubmission, {
+                                        sectionKey: result.sectionKey,
+                                        questionKey: result.questionKey,
+                                        value: valueToPersist,
+                                        commentId: result.commentId,
+                                    });
+                                }
+                                else {
+                                    await this.formSubmissionHandler.addComment(this.udpFormSubmission, {
+                                        sectionKey: result.sectionKey,
+                                        questionKey: result.questionKey,
+                                        value: valueToPersist,
+                                        commentId: result.commentId,
+                                    });
+                                }
+                                await this.refreshSubmissionAndSyncState();
+                                enqueueSnackbarSuccess(existingSavedComment ? 'Comment updated.' : 'Comment added.', this.enqueueSnackbar);
+                            }
+                            catch (error) {
+                                enqueueSnackbarError(existingSavedComment ? 'Failed to update comment.' : 'Failed to add comment.', this.enqueueSnackbar);
+                                throw error;
+                            }
+                        }
                     }
-                    // remove that draft
-                    newCurrentValues[sectionName][questionName].draftComments = draftsArr.filter(d => d.commentId !== commentId);
-                    break;
-                }
-                case 'edit': {
-                    // create a draft copy of the saved comment but DO NOT remove the saved comment from the list.
-                    const saved = commentsArr.find(c => c.commentId === commentId);
-                    if (!saved)
-                        return;
-                    const draftFromSaved = Object.assign(Object.assign({}, saved), { isDraftComment: true, timestamp: null });
-                    // Add this draft at the front; keep saved comment intact so content doesn't disappear.
-                    newCurrentValues[sectionName][questionName].draftComments = [draftFromSaved, ...draftsArr];
-                    newCurrentValues[sectionName][questionName].comments = commentsArr;
-                    break;
-                }
-                case 'delete': {
-                    // mark the comment as deleted and clear its value, then persist.
-                    newCurrentValues[sectionName][questionName].comments = commentsArr.map(c => {
-                        if (c.commentId === commentId) {
-                            return Object.assign(Object.assign({}, c), { isDeleted: true, value: '', editedTimestamp: new Date().toISOString() });
+                    else if (type === 'delete') {
+                        try {
+                            await this.formSubmissionHandler.deleteComment(this.udpFormSubmission, {
+                                sectionKey: result.sectionKey,
+                                questionKey: result.questionKey,
+                                commentId: result.commentId,
+                            });
+                            await this.refreshSubmissionAndSyncState();
+                            enqueueSnackbarSuccess('Comment deleted.', this.enqueueSnackbar);
                         }
-                        return c;
-                    });
-                    break;
+                        catch (error) {
+                            enqueueSnackbarError('Failed to delete comment.', this.enqueueSnackbar);
+                            throw error;
+                        }
+                    }
                 }
-                case 'editClose': {
-                    // Cancel edit: remove the draft only, do NOT restore/alter saved comments.
-                    newCurrentValues[sectionName][questionName].draftComments = draftsArr.filter(d => d.commentId !== commentId);
-                    break;
+                else {
+                    // Not submitted yet:
+                    // - public: persist nothing beyond local state (submission is created on submit)
+                    // - private + owner: comment edits are persisted via standard submission save
+                    if (this.isPublic) {
+                        this.currentValues = Object.assign({}, newCurrentValues);
+                    }
+                    else {
+                        await this.handleManualSave(newCurrentValues);
+                    }
                 }
             }
-            // if it's a save or delete action, persist immediately
-            if (type === 'save' || type === 'delete') {
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
-                await this.handleCommmentUpdate(newCurrentValues);
-            }
             else {
+                // Non-persisting actions update UI state only
                 this.currentValues = Object.assign({}, newCurrentValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newCurrentValues);
             }
         }
         catch (error) {
@@ -1295,7 +1278,6 @@ const UdpFormsRenderer = class {
     async loadFollowUpForms(sectionKey, questionKey) {
         var _a;
         this.isLoading = true;
-        this.saveErrorMessage = '';
         try {
             const response = await fetchLatestForms(this.followUpSideSheetListPageNumber, this.FOLLOW_UP_SIDE_SHEET_PAGE_SIZE, [{ searchField: 'type', searchOperator: '=', searchValue: UdpFormsTypeEnum.FollowUp }], { sortDirection: 'DESC', sortColumn: 'lastModifiedOn' });
             const data = response.data;
@@ -1307,7 +1289,6 @@ const UdpFormsRenderer = class {
         }
         catch (err) {
             console.error('Failed to follow up form.', err);
-            this.saveErrorMessage = 'Failed to follow up forms.';
         }
         finally {
             this.isLoading = false;
@@ -1325,11 +1306,17 @@ const UdpFormsRenderer = class {
         await this.loadFollowUpForms(this.followUpParentSectionKey, this.followUpParentQuestionKey);
     }
     renderFollowUpSideSheet() {
+        if (this.isPublic)
+            return null;
         return (h("udp-side-sheet", { title: "Link a Follow Up Form", open: this.isFollowUpFormsSideSheetOpen, onUdpSideSheetClose: () => this.handleSideSheetClose(), position: "right", width: "md" }, this.isLoading && this.isFollowUpFormsSideSheetOpen && h("udp-linear-loader", null), h("udp-list-renderer", { itemComponent: "udp-forms-follow-up-list-card", data: this.sideSheetFollowUpFormsList, pagination: true, isServerSide: true, isLoading: this.isLoading, itemsPerPage: this.FOLLOW_UP_SIDE_SHEET_PAGE_SIZE, currentPage: this.followUpSideSheetListPageNumber, totalItems: this.followUpSideSheetTotalItems, onPageChange: e => this.handleSideSheetPageChange(e.detail), componentDataMap: this.componentMap, spacing: 'md' })));
     }
     isShowManualSaveIcon() {
-        // return (this.isFormDirty || this.isUserUpdatedSections) && !this.isSubmitted && !!this.userId;
-        const showSaveIcon = (this.isFormDirty || this.isUserUpdatedSections) && !!this.clientUserInfo.id;
+        if (this.isPublic)
+            return false; // cannot save a form in public mode. can only submit. 
+        // NOTE: repeatable section add/delete sets hasUnsavedChanges=true, but udp-forms-ui likely
+        // also emits a formDirtyChange event that can override the value back to false.
+        // Keep the save icon sticky once we've detected any unsaved change.
+        const showSaveIcon = !!this.clientUserInfo.id && (this.hasUnsavedChanges);
         return showSaveIcon;
     }
     ;
@@ -1337,7 +1324,8 @@ const UdpFormsRenderer = class {
         return this.isSubmitted || this.udpFormSubmission.unityUserId !== this.clientUserInfo.id;
     }
     render() {
-        return (h("div", { key: 'd073bfa6145e449c59dc722723ac82d09730d885', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), h("udp-forms-ui", { udpForm: this.udpForm, currentValues: this.currentValues, udpFormSubmission: this.udpFormSubmission, submitSuccessful: this.submitSuccessful, isSaving: this.isSaving, saveErrorMessage: this.saveErrorMessage,
+        return (h("div", { key: '37ec47fc7f3ecec70ba7ca3e12717789285be5d8', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), h("udp-forms-ui", { udpForm: this.udpForm, currentValues: this.currentValues, udpFormSubmission: this.udpFormSubmission, submitSuccessful: this.submitSuccessful, isSaving: this.isSaving,
+            // saveErrorMessage={this.saveErrorMessage}
             // showAutoSaveStatus={this.formSubmissionHandler.supportsAutoSave() && !!this.userId}
             readonly: this.isReadOnlyMode, handleSubmit: this.handleSubmit.bind(this), handleSave: values => Promise.resolve(this.debouncedManualSave(values)), handleChange: this.handleFormChange, handleAction: this.triggerAction, handleFinish: this.handleFinish, clientUserInfo: this.clientUserInfo, isSubmitted: this.isSubmitted, dynamicSections: this.dynamicSections, duplicateRepeatableSection: this.duplicateRepeatableSection, deleteRepeatableSection: this.deleteRepeatableSection, key: `form-rerender-key-${this.reRenderKey}`, isShowManualSaveIcon: this.isShowManualSaveIcon(), isLoading: this.isLoading, performBackgroundSaveAndUpdateLocalSubmissionState: this.performBackgroundSaveAndUpdateLocalSubmissionState })));
     }