udp-stencil-component-library 25.18.2-beta.1 → 25.18.2-beta.11

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

@@ -1,11 +1,11 @@
 'use strict';
 
-var index = require('./index-CGCOXUJE.js');
+var index = require('./index-SNloIaSR.js');
 var lodash = require('lodash');
-var enums = require('./enums-DVbZnzL8.js');
 var tenantUtils = require('./tenantUtils-BCKSE0vq.js');
 var udpFormApiUtils = require('./udp-form-api-utils-BwNeblH_.js');
-var utils = require('./utils-DZ_OMtAy.js');
+var enums = require('./enums-B3aaCQaV.js');
+var utils = require('./utils-Bp02BX38.js');
 var makeApiCall = require('./makeApiCall-CFfg9gI0.js');
 var SearchBuilder = require('./SearchBuilder-C1sUitjQ.js');
 var configService = require('./configService-BmGAegZf.js');
@@ -24,67 +24,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 makeApiCall.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;
@@ -111,15 +50,13 @@ class UdpFormSubmission {
     // Form Data Processing
     // =============================
     processSubmissionIntoFormDataWithoutValues(status) {
-        const statusValue = this.resolveSubmissionStatus(status);
-        const baseData = this.buildBaseSubmissionData(statusValue);
+        const baseData = this.buildBaseSubmissionData(status);
         const formData = makeApiCall.createFormData(baseData);
         formData.append('Data', JSON.stringify(this.data));
         return formData;
     }
     processSubmissionIntoFormData(formInputValuesAndMetadata, status) {
-        const statusValue = this.resolveSubmissionStatus(status);
-        const baseData = this.buildBaseSubmissionData(statusValue);
+        const baseData = this.buildBaseSubmissionData(status);
         const { cleanedData, files } = this.extractCleanedDataAndFiles(formInputValuesAndMetadata);
         const formData = makeApiCall.createFormData(baseData);
         files.forEach(file => formData.append('FormFiles', file));
@@ -130,18 +67,11 @@ class UdpFormSubmission {
         formData.append('Data', JSON.stringify(submissionDataObject));
         return formData;
     }
-    resolveSubmissionStatus(status) {
-        if (status === 'submitted')
-            return 2;
-        if (status === 'in-progress')
-            return 1;
-        return typeof status === 'number' ? status : 1;
-    }
     buildBaseSubmissionData(statusValue) {
         const baseData = {
             FormId: this.formId,
             FormVersion: this.formVersion.toString(),
-            Status: statusValue.toString(),
+            Status: statusValue,
         };
         if (this.id) {
             baseData.Id = this.id;
@@ -226,259 +156,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.ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${this.accessMode}`;
+        await makeApiCall.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.SearchBuilder(1, 1)
-                .addFilter('id', id, SearchBuilder.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.ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${commentId}`;
+        await makeApiCall.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.ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}/comments/${commentId}`;
+        await makeApiCall.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.SearchBuilder(1, 1)
-                .addFilter('id', id, SearchBuilder.SearchOperators.EQUALS);
-            if (generic1) {
-                search.addFilter('generic1', generic1, SearchBuilder.SearchOperators.EQUALS);
-            }
-            if (generic2) {
-                search.addFilter('generic2', generic2, SearchBuilder.SearchOperators.EQUALS);
-            }
-            if (generic3) {
-                search.addFilter('generic3', generic3, SearchBuilder.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, 'in-progress');
-        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.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, enums.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) {
-        return this.saveSubmissionToDB(values, udpFormSubmission, 'in-progress');
+        if (this.accessMode === 'public') {
+            // Public forms do not support draft save / return-later.
+            return udpFormSubmission;
+        }
+        return this.saveSubmissionToDB(values, udpFormSubmission, enums.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, 'submitted');
+        return this.saveSubmissionToDB(values, udpFormSubmission, enums.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.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.ConfigService.productV1ApiUrl}/UdpFormSubmission`;
+        const baseUrl = `${configService.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.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.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.SearchBuilder(1, 1).addFilter('id', id, SearchBuilder.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 = udpFormSubmission.status || 2; // default to 'submitted' if status is null
-            const url = `${configService.ConfigService.productV1ApiUrl}/UdpFormSubmission/${udpFormSubmission.id}`;
-            const formData = udpFormSubmission.processSubmissionIntoFormData(values, status);
-            const response = await makeApiCall.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.SearchBuilder(1, 1)
+                .addFilter('id', id, SearchBuilder.SearchOperators.EQUALS)
+                .addFilter('unityUserId', unityUserId, SearchBuilder.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;
         }
     }
 }
@@ -487,36 +296,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.makeApiCall('GET', `${configService.ConfigService.productV1ApiUrl}/UdpForm/${formId}/describe`);
-        if (formData.styleOverrides && typeof formData.styleOverrides === 'string') {
-            formData.styleOverrides = JSON.parse(formData.styleOverrides);
+    buildDescribeUrl(formId, formVersion) {
+        const base = configService.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.makeApiCall('GET', `${configService.ConfigService.productV1ApiUrl}/UdpForm/${formId}/${formVersion}/describe`);
+        const url = this.buildDescribeUrl(formId, formVersion);
+        const formData = await makeApiCall.makeApiCall('GET', url);
         if (formData.styleOverrides && typeof formData.styleOverrides === 'string') {
             formData.styleOverrides = JSON.parse(formData.styleOverrides);
         }
@@ -532,23 +333,515 @@ class UdpForm {
     }
 }
 
+// utility to find repeat group keys from current values
+const findRepeatGroupKeys = (sectionName, values) => {
+    const keys = Object.keys(values);
+    const repeatGroupSet = new Set();
+    // Match: sectionName_2
+    const regex = new RegExp(`^${sectionName}_(\\d+)`);
+    keys.forEach(key => {
+        const match = key.match(regex);
+        if (match && match[1]) {
+            repeatGroupSet.add(Number(match[1]));
+        }
+    });
+    return Array.from(repeatGroupSet).sort((a, b) => a - b);
+};
+// build dynamic sections based on the master form
+const initializeDynamicSections = (udpForm, currentValues) => {
+    var _a;
+    const dynamicSections = [];
+    const sortedSections = structuredClone(udpForm.udpFormUdpFormSection).sort((a, b) => a.order - b.order);
+    for (const section of sortedSections) {
+        section.sectionProperties = JSON.parse(section.sectionProperties || {});
+        const repeatGroupKeys = findRepeatGroupKeys(section.name, currentValues);
+        section.isOriginalSection = true;
+        section.sectionPositionSuffix = 1; // default position
+        // always add the original section into dynamic sections
+        dynamicSections.push(Object.assign(Object.assign({}, structuredClone(section)), {
+            // dynamicSectionName: section.name,
+            formQuestions: structuredClone(udpForm.formQuestions)
+                .filter(q => q.formSectionId === section.id)
+                .sort((a, b) => a.questionOrder - b.questionOrder)
+                .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}.${q.name}`, isShowCommentInput: true })))
+        }));
+        // create then add additional sections if there are repeated sections
+        if (((_a = section.sectionProperties) === null || _a === void 0 ? void 0 : _a.isRepeatable) && repeatGroupKeys.length > 0) {
+            const maxRepeatedSectionSuffix = Math.max(...repeatGroupKeys); // create a new section for the max value of repeat group keys, even if there are no saved answers
+            // for (const repeatKey of repeatGroupKeys) { // create a section only for the suffix saved
+            for (let repeatKey = 2; repeatKey <= maxRepeatedSectionSuffix; repeatKey++) {
+                const clonedSection = Object.assign(Object.assign({}, structuredClone(section)), { formQuestions: structuredClone(udpForm.formQuestions)
+                        .filter(q => q.formSectionId === section.id)
+                        .sort((a, b) => a.questionOrder - b.questionOrder)
+                        .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}_${repeatKey}.${q.name}`, isShowCommentInput: true }))), isOriginalSection: false, sectionPositionSuffix: repeatKey });
+                dynamicSections.push(clonedSection);
+            }
+        }
+    }
+    return dynamicSections;
+};
+// urlContext is derived from query params that start with `udpf_` (see useUdpFormParameters).
+// Keys are stored without the prefix, e.g. `udpf_section1_3.question1=val` -> urlContext['section1_3.question1'] = 'val'
+// This helper finds the maximum repeat suffix requested by urlContext for a given section base name.
+// Example: { 'sectionA_3.q1': 'x', 'sectionA_2.q2': 'y' } -> { sectionA: 3 }
+const getMaxRepeatSuffixBySectionFromUrlContext = (urlContext) => {
+    const context = (urlContext && typeof urlContext === 'object') ? urlContext : {};
+    const maxBySection = {};
+    Object.keys(context).forEach(key => {
+        var _a;
+        // Expect keys like: sectionName_3.questionName
+        // Only treat it as a repeat hint if it has a dot after the suffix.
+        const match = key.match(/^([^._?&#]+)_(\d+)\./);
+        if (!match)
+            return;
+        const baseSectionName = match[1];
+        const suffix = Number(match[2]);
+        if (!Number.isFinite(suffix) || suffix < 2)
+            return;
+        const existing = (_a = maxBySection[baseSectionName]) !== null && _a !== void 0 ? _a : 1;
+        if (suffix > existing)
+            maxBySection[baseSectionName] = suffix;
+    });
+    return maxBySection;
+};
+// build dynamic sections based on the master form plus optional repeat hints from URL context
+const initializeDynamicSectionsWithUrlContext = (udpForm, currentValues, urlContext) => {
+    var _a, _b;
+    const maxRepeatFromUrl = getMaxRepeatSuffixBySectionFromUrlContext(urlContext);
+    const dynamicSections = [];
+    const sortedSections = structuredClone(udpForm.udpFormUdpFormSection).sort((a, b) => a.order - b.order);
+    for (const section of sortedSections) {
+        section.sectionProperties = JSON.parse(section.sectionProperties || {});
+        const repeatGroupKeys = findRepeatGroupKeys(section.name, currentValues);
+        const maxRepeatedFromValues = repeatGroupKeys.length > 0 ? Math.max(...repeatGroupKeys) : 1;
+        const maxRepeatedFromUrl = (_a = maxRepeatFromUrl === null || maxRepeatFromUrl === void 0 ? void 0 : maxRepeatFromUrl[section.name]) !== null && _a !== void 0 ? _a : 1;
+        const maxRepeatedSectionSuffix = Math.max(maxRepeatedFromValues, maxRepeatedFromUrl);
+        section.isOriginalSection = true;
+        section.sectionPositionSuffix = 1; // default position
+        // always add the original section into dynamic sections
+        dynamicSections.push(Object.assign(Object.assign({}, structuredClone(section)), { formQuestions: structuredClone(udpForm.formQuestions)
+                .filter(q => q.formSectionId === section.id)
+                .sort((a, b) => a.questionOrder - b.questionOrder)
+                .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}.${q.name}`, isShowCommentInput: true }))) }));
+        // create then add additional sections if repeatable and suffix requested by saved values or url
+        if (((_b = section.sectionProperties) === null || _b === void 0 ? void 0 : _b.isRepeatable) && maxRepeatedSectionSuffix >= 2) {
+            for (let repeatKey = 2; repeatKey <= maxRepeatedSectionSuffix; repeatKey++) {
+                const clonedSection = Object.assign(Object.assign({}, structuredClone(section)), { formQuestions: structuredClone(udpForm.formQuestions)
+                        .filter(q => q.formSectionId === section.id)
+                        .sort((a, b) => a.questionOrder - b.questionOrder)
+                        .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}_${repeatKey}.${q.name}`, isShowCommentInput: true }))), isOriginalSection: false, sectionPositionSuffix: repeatKey });
+                dynamicSections.push(clonedSection);
+            }
+        }
+    }
+    return dynamicSections;
+};
+const applyUrlSeedValuesForAll = (dynamicSections, urlContext) => {
+    if (!Array.isArray(dynamicSections))
+        return;
+    // urlContext is derived from query params that start with `udpf_` (see useUdpFormParameters).
+    // Keys are stored without the prefix, e.g. `udpf_section1.question1=val` -> urlContext['section1.question1'] = 'val'
+    const context = (urlContext && typeof urlContext === 'object') ? urlContext : {};
+    // Build a case-insensitive view of urlContext so callers can use udpf_ keys without worrying about case.
+    // If duplicate keys exist with different casing, the last one encountered wins.
+    const contextCI = {};
+    Object.keys(context).forEach(k => {
+        contextCI[String(k).toLowerCase()] = context[k];
+    });
+    // 1) Collect URL values into nested structure: { [sectionKey]: { [questionName]: { value, comments: [] } } }
+    const urlValuesNested = {};
+    dynamicSections.forEach(section => {
+        const sectionKey = section.isOriginalSection
+            ? section.name
+            : `${section.name}_${section.sectionPositionSuffix}`;
+        (section.formQuestions || []).forEach(q => {
+            if (!q)
+                return;
+            const candidates = [q.processedSubmissionName, q.questionIdentifierKey, q.name].filter(Boolean);
+            let urlVal = undefined;
+            for (const c of candidates) {
+                const key = String(c).toLowerCase();
+                if (Object.prototype.hasOwnProperty.call(contextCI, key)) {
+                    urlVal = contextCI[key];
+                    break;
+                }
+            }
+            if (urlVal !== undefined && urlVal !== null) {
+                if (!urlValuesNested[sectionKey])
+                    urlValuesNested[sectionKey] = {};
+                urlValuesNested[sectionKey][q.name] = { value: urlVal, comments: [] };
+            }
+        });
+    });
+    // Caller is responsible for merging with saved submissionResponseData.
+    // Here we only return the url-derived seed values + paragraph defaults.
+    const merged = {};
+    Object.entries(urlValuesNested).forEach(([sectionKey, qMap]) => {
+        if (!merged[sectionKey])
+            merged[sectionKey] = {};
+        Object.entries(qMap).forEach(([qName, valObj]) => {
+            const existing = merged[sectionKey][qName];
+            // Only set from URL if no saved value exists (null/undefined/empty-string)
+            const isMissing = existing == null ||
+                existing.value == null ||
+                (typeof existing.value === 'string' && existing.value.trim() === '');
+            if (isMissing) {
+                merged[sectionKey][qName] = valObj;
+            }
+        });
+    });
+    // 3) Paragraph defaults: if still undefined/null, use fieldProperties.paragraphText
+    dynamicSections.forEach(section => {
+        const sectionKey = section.isOriginalSection
+            ? section.name
+            : `${section.name}_${section.sectionPositionSuffix}`;
+        if (!merged[sectionKey])
+            merged[sectionKey] = {};
+        (section.formQuestions || []).forEach(q => {
+            var _a;
+            if (!q)
+                return;
+            if (q.fieldTypeId === enums.UdpFormsFieldTypeEnum.Paragraph) {
+                const existing = merged[sectionKey][q.name];
+                const isMissing = existing == null ||
+                    existing.value == null ||
+                    (typeof existing.value === 'string' && existing.value.trim() === '');
+                if (isMissing) {
+                    let fieldProps = q === null || q === void 0 ? void 0 : q.fieldProperties;
+                    if (typeof fieldProps === 'string') {
+                        try {
+                            fieldProps = JSON.parse(fieldProps || '{}');
+                        }
+                        catch (_b) {
+                            fieldProps = {};
+                        }
+                    }
+                    merged[sectionKey][q.name] = {
+                        value: (_a = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.paragraphText) !== null && _a !== void 0 ? _a : '',
+                        comments: [],
+                    };
+                }
+            }
+        });
+    });
+    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/${enums.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 === enums.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: uuid.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) {
         index.registerInstance(this, hostRef);
         this.isPublic = false;
         this.autoSaveDelay = 2000; // Debounce delay for auto-save in milliseconds (currently disabled)
-        this.initialValues = {};
+        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.submitSuccessful = false;
-        this.currentFormData = {};
         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.
@@ -568,9 +861,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);
@@ -589,75 +892,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 = this.findRepeatGroupKeys(cloningSectionName, this.initialValues);
-                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 newInitialValues = structuredClone(this.udpFormSubmission.data.submissionResponseData);
-                clonedSection.formQuestions.forEach(q => {
-                    var _a, _b, _c, _d;
-                    const newSectionNameWithSuffix = `${cloningSectionName}_${nextRepeatIndex}`;
-                    const newQuestionName = q.name;
-                    if (!newInitialValues[newSectionNameWithSuffix]) {
-                        newInitialValues[newSectionNameWithSuffix] = {};
-                    }
-                    // Preserve only Paragraph values from the source section; clear others
-                    let value = '';
-                    if (q.fieldTypeId === enums.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;
-                    }
-                    newInitialValues[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.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                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;
             }
         };
         /**
@@ -672,137 +920,90 @@ const UdpFormsRenderer = class {
             this.isUpdatingSections = true;
             this.isLoading = true;
             try {
-                const deleteSectionName = sectionToDelete.name;
-                const deleteSuffix = sectionToDelete.sectionPositionSuffix;
-                const sectionKeyToDelete = `${deleteSectionName}_${deleteSuffix}`;
-                const newInitialValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
-                delete newInitialValues[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 (newInitialValues[oldSectionKey]) {
-                        newInitialValues[newSectionKey] = structuredClone(newInitialValues[oldSectionKey]);
-                        delete newInitialValues[oldSectionKey];
-                    }
+                const { nextDynamicSections, nextValues } = computeDeleteRepeatableSection({
+                    dynamicSections: this.dynamicSections,
+                    values: Object.assign({}, (this.udpFormSubmission.data.submissionResponseData || {})),
+                    index,
                 });
-                this.dynamicSections = updatedSections;
-                this.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                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.initialValues = 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 === enums.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.initialValues = 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.initialValues = 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) => {
@@ -832,7 +1033,7 @@ const UdpFormsRenderer = class {
             // create a new follow up form submission instance wiht a link to the parent form submission
             const followUpMasterForm = await this.formHandler.getFormByFormIdAndFormVersion(followUpFormId, followUpFormVersion);
             const followUpSubmissionData = {
-                submissionResponseData: utils.buildEmptyInitialValues(followUpMasterForm),
+                submissionResponseData: utils.buildEmptyCurrentValues(followUpMasterForm),
                 submissionMetadata: {
                     ParentSubmission: {
                         submissionId: parentFormSubmissionId,
@@ -869,7 +1070,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;
             });
         }
     }
@@ -878,17 +1081,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.generic1, generic2: this.generic2, generic3: this.generic3 });
+            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
@@ -905,18 +1115,29 @@ const UdpFormsRenderer = class {
             this.formHandler = new UdpFormHandler(this.tenantId);
             const formData = await this.formHandler.getFormByFormIdAndFormVersion(formId, formVersion);
             this.udpForm = new UdpForm(formData);
-            this.initialValues = utils.buildEmptyInitialValues(this.udpForm);
+            this.currentValues = utils.buildEmptyCurrentValues(this.udpForm);
             // if there's existing data, update the form's state
             if (this.udpFormSubmission.data.submissionResponseData) {
-                this.initialValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
-                if (this.udpFormSubmission.status === 2 || this.udpFormSubmission.status === 'submitted') {
+                this.currentValues = Object.assign({}, this.udpFormSubmission.data.submissionResponseData);
+                if (this.udpFormSubmission.status === enums.UdpFormsSubmissionStatusEnum.Submitted) {
                     this.isSubmitted = true;
                 }
             }
-            this.initializeDynamicSections(); // process the master form into dynamic sections 
-            // After sections/questions are prepared, seed initial values from URL for ALL questions,
-            // with saved values taking precedence, and paragraph defaults as a fallback.
-            this.applyUrlInitialValuesForAll();
+            // For new submissions (un-instiantiated or in the 'created' status), we allow the seeding of initial values from URL params
+            // So we build dynamicSections with urlContext first, then seed values.
+            // URL params (udpf_*) may imply repeatable section instances (e.g. section1_3.question1).
+            // For existing submissions that are in progress, skip URL-based seeding and do not create additional sections from URL.
+            if ((!this.udpFormSubmission.id || this.udpFormSubmission.status === enums.UdpFormsSubmissionStatusEnum.Created) && this.urlContext && Object.keys(this.urlContext).length > 0) {
+                this.dynamicSections = initializeDynamicSectionsWithUrlContext(this.udpForm, this.currentValues, this.urlContext);
+                const seeded = applyUrlSeedValuesForAll(this.dynamicSections, this.urlContext);
+                if (seeded) {
+                    this.currentValues = seeded;
+                    this.udpFormSubmission.data.submissionResponseData = Object.assign({}, seeded);
+                }
+            }
+            else {
+                this.dynamicSections = initializeDynamicSections(this.udpForm, this.currentValues);
+            }
             // Set up throttled manual save function (5 seconds) - fires immediately, then throttles
             this.debouncedManualSave = lodash.throttle(async (values) => {
                 await this.handleManualSave(values);
@@ -933,290 +1154,120 @@ const UdpFormsRenderer = class {
             this.isLoading = false;
         }
     }
-    // build dynamic sections based on the
-    initializeDynamicSections() {
-        var _a;
-        const tempDynamicSection = [];
-        const sortedSections = structuredClone(this.udpForm.udpFormUdpFormSection).sort((a, b) => a.order - b.order);
-        for (const section of sortedSections) {
-            section.sectionProperties = JSON.parse(section.sectionProperties || {});
-            const repeatGroupKeys = this.findRepeatGroupKeys(section.name, this.initialValues);
-            section.isOriginalSection = true;
-            section.sectionPositionSuffix = 1; // default position
-            // always add the original section into dynamic sections
-            tempDynamicSection.push(Object.assign(Object.assign({}, structuredClone(section)), {
-                // dynamicSectionName: section.name,
-                formQuestions: structuredClone(this.udpForm.formQuestions)
-                    .filter(q => q.formSectionId === section.id)
-                    .sort((a, b) => a.questionOrder - b.questionOrder)
-                    .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}.${q.name}`, isShowCommentInput: true })))
-            }));
-            // create then add additional sections if there are repeated sections
-            if (((_a = section.sectionProperties) === null || _a === void 0 ? void 0 : _a.isRepeatable) && repeatGroupKeys.length > 0) {
-                const maxRepeatedSectionSuffix = Math.max(...repeatGroupKeys); // create a new section for the max value of repeat group keys, even if there are no saved answers
-                // for (const repeatKey of repeatGroupKeys) { // create a section only for the suffix saved
-                for (let repeatKey = 2; repeatKey <= maxRepeatedSectionSuffix; repeatKey++) {
-                    const clonedSection = Object.assign(Object.assign({}, structuredClone(section)), { formQuestions: structuredClone(this.udpForm.formQuestions)
-                            .filter(q => q.formSectionId === section.id)
-                            .sort((a, b) => a.questionOrder - b.questionOrder)
-                            .map(q => (Object.assign(Object.assign({}, q), { questionIdentifierKey: `${section.name}_${repeatKey}.${q.name}`, isShowCommentInput: true }))), isOriginalSection: false, sectionPositionSuffix: repeatKey });
-                    tempDynamicSection.push(clonedSection);
-                }
-            }
-        }
-        this.dynamicSections = tempDynamicSection;
-    }
-    findRepeatGroupKeys(sectionName, values) {
-        const keys = Object.keys(values);
-        const repeatGroupSet = new Set();
-        // Match: sectionName_2
-        const regex = new RegExp(`^${sectionName}_(\\d+)`);
-        keys.forEach(key => {
-            const match = key.match(regex);
-            if (match && match[1]) {
-                repeatGroupSet.add(Number(match[1]));
-            }
-        });
-        return Array.from(repeatGroupSet).sort((a, b) => a - b);
-    }
-    // Build initial values from URL for ALL fields, but do NOT override saved values.
-    // For Paragraph, also fall back to the builder's default text when nothing else provided.
-    applyUrlInitialValuesForAll() {
-        if (!Array.isArray(this.dynamicSections))
-            return;
-        const urlParams = typeof window !== 'undefined' ? new URLSearchParams(window.location.search) : null;
-        // 1) Collect URL values into nested structure: { [sectionKey]: { [questionName]: { value, comments: [] } } }
-        const urlValuesNested = {};
-        if (urlParams) {
-            this.dynamicSections.forEach(section => {
-                const sectionKey = section.isOriginalSection
-                    ? section.name
-                    : `${section.name}_${section.sectionPositionSuffix}`;
-                (section.formQuestions || []).forEach(q => {
-                    if (!q)
-                        return;
-                    const candidates = [q.processedSubmissionName, q.questionIdentifierKey, q.name].filter(Boolean);
-                    let urlVal = null;
-                    for (const c of candidates) {
-                        urlVal = urlParams.get(c);
-                        if (urlVal !== null)
-                            break;
-                    }
-                    if (urlVal !== null) {
-                        if (!urlValuesNested[sectionKey])
-                            urlValuesNested[sectionKey] = {};
-                        urlValuesNested[sectionKey][q.name] = { value: urlVal, comments: [] };
-                    }
-                });
-            });
-        }
-        // 2) Merge with saved values (this.initialValues) taking precedence
-        const merged = structuredClone(this.initialValues) || {};
-        Object.entries(urlValuesNested).forEach(([sectionKey, qMap]) => {
-            if (!merged[sectionKey])
-                merged[sectionKey] = {};
-            Object.entries(qMap).forEach(([qName, valObj]) => {
-                const existing = merged[sectionKey][qName];
-                // Only set from URL if no saved value exists (null/undefined/empty-string)
-                const isMissing = existing == null ||
-                    existing.value == null ||
-                    (typeof existing.value === 'string' && existing.value.trim() === '');
-                if (isMissing) {
-                    merged[sectionKey][qName] = valObj;
-                }
-            });
-        });
-        // 3) Paragraph defaults: if still undefined/null, use fieldProperties.paragraphText
-        this.dynamicSections.forEach(section => {
-            const sectionKey = section.isOriginalSection
-                ? section.name
-                : `${section.name}_${section.sectionPositionSuffix}`;
-            if (!merged[sectionKey])
-                merged[sectionKey] = {};
-            (section.formQuestions || []).forEach(q => {
-                var _a;
-                if (!q)
-                    return;
-                if (q.fieldTypeId === enums.UdpFormsFieldTypeEnum.Paragraph) {
-                    const existing = merged[sectionKey][q.name];
-                    const isMissing = existing == null ||
-                        existing.value == null ||
-                        (typeof existing.value === 'string' && existing.value.trim() === '');
-                    if (isMissing) {
-                        let fieldProps = q === null || q === void 0 ? void 0 : q.fieldProperties;
-                        if (typeof fieldProps === 'string') {
-                            try {
-                                fieldProps = JSON.parse(fieldProps || '{}');
-                            }
-                            catch (_b) {
-                                fieldProps = {};
-                            }
-                        }
-                        merged[sectionKey][q.name] = {
-                            value: (_a = fieldProps === null || fieldProps === void 0 ? void 0 : fieldProps.paragraphText) !== null && _a !== void 0 ? _a : '',
-                            comments: [],
-                        };
-                    }
-                }
-            });
-        });
-        this.initialValues = merged;
-        this.udpFormSubmission.data.submissionResponseData = Object.assign({}, merged);
-    }
     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/${enums.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 newInitialValues = structuredClone(this.udpFormSubmission.data.submissionResponseData || {});
-            // ensure structure exists WITHOUT overwriting existing data
-            if (!newInitialValues[sectionName])
-                newInitialValues[sectionName] = {};
-            if (!newInitialValues[sectionName][questionName]) {
-                // create defaults but do not clobber any existing saved shape from submissionResponseData
-                newInitialValues[sectionName][questionName] = {
-                    value: '',
-                    comments: [],
-                    draftComments: [],
-                    metadata: {},
-                };
-            }
-            else {
-                // ensure arrays/objects exist so later code can safely push/filter
-                newInitialValues[sectionName][questionName].comments = (_a = newInitialValues[sectionName][questionName].comments) !== null && _a !== void 0 ? _a : [];
-                newInitialValues[sectionName][questionName].draftComments = (_b = newInitialValues[sectionName][questionName].draftComments) !== null && _b !== void 0 ? _b : [];
-                newInitialValues[sectionName][questionName].metadata = (_c = newInitialValues[sectionName][questionName].metadata) !== null && _c !== void 0 ? _c : {};
-            }
-            // normalize draftComments to array if needed (back-compat)
-            const maybeDraft = newInitialValues[sectionName][questionName].draftComments;
-            if (maybeDraft && !Array.isArray(maybeDraft)) {
-                newInitialValues[sectionName][questionName].draftComments = [maybeDraft];
-            }
-            else if (!maybeDraft) {
-                newInitialValues[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 = newInitialValues[sectionName][questionName].comments || [];
-            const draftsArr = newInitialValues[sectionName][questionName].draftComments || [];
-            switch (type) {
-                case 'add': {
-                    const newDraft = {
-                        value: '',
-                        commentId: uuid.v4(),
-                        isTempComment: true,
-                        timestamp: null,
-                    };
-                    // put new draft first so activeDraft === draftComments[0] matches UX
-                    newInitialValues[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);
-                        newInitialValues[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) === enums.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 {
-                        newInitialValues[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
-                    newInitialValues[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.
-                    newInitialValues[sectionName][questionName].draftComments = [draftFromSaved, ...draftsArr];
-                    newInitialValues[sectionName][questionName].comments = commentsArr;
-                    break;
-                }
-                case 'delete': {
-                    // mark the comment as deleted and clear its value, then persist.
-                    newInitialValues[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.
-                    newInitialValues[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({}, newInitialValues);
-                await this.handleCommmentUpdate(newInitialValues);
-            }
             else {
-                this.initialValues = Object.assign({}, newInitialValues);
-                this.udpFormSubmission.data.submissionResponseData = Object.assign({}, newInitialValues);
+                // Non-persisting actions update UI state only
+                this.currentValues = Object.assign({}, newCurrentValues);
             }
         }
         catch (error) {
@@ -1229,7 +1280,6 @@ const UdpFormsRenderer = class {
     async loadFollowUpForms(sectionKey, questionKey) {
         var _a;
         this.isLoading = true;
-        this.saveErrorMessage = '';
         try {
             const response = await udpFormApiUtils.fetchLatestForms(this.followUpSideSheetListPageNumber, this.FOLLOW_UP_SIDE_SHEET_PAGE_SIZE, [{ searchField: 'type', searchOperator: '=', searchValue: enums.UdpFormsTypeEnum.FollowUp }], { sortDirection: 'DESC', sortColumn: 'lastModifiedOn' });
             const data = response.data;
@@ -1241,7 +1291,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;
@@ -1259,11 +1308,17 @@ const UdpFormsRenderer = class {
         await this.loadFollowUpForms(this.followUpParentSectionKey, this.followUpParentQuestionKey);
     }
     renderFollowUpSideSheet() {
+        if (this.isPublic)
+            return null;
         return (index.h("udp-side-sheet", { title: "Link a Follow Up Form", open: this.isFollowUpFormsSideSheetOpen, onUdpSideSheetClose: () => this.handleSideSheetClose(), position: "right", width: "md" }, this.isLoading && this.isFollowUpFormsSideSheetOpen && index.h("udp-linear-loader", null), index.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;
     }
     ;
@@ -1271,7 +1326,8 @@ const UdpFormsRenderer = class {
         return this.isSubmitted || this.udpFormSubmission.unityUserId !== this.clientUserInfo.id;
     }
     render() {
-        return (index.h("div", { key: 'c0adb1a4f78f6ff15ce946b44677820f716e8a86', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), index.h("udp-forms-ui", { udpForm: this.udpForm, initialValues: this.initialValues, udpFormSubmission: this.udpFormSubmission, submitSuccessful: this.submitSuccessful, isSaving: this.isSaving, saveErrorMessage: this.saveErrorMessage,
+        return (index.h("div", { key: '37ec47fc7f3ecec70ba7ca3e12717789285be5d8', class: "forms-renderer-container", style: this.isLoading ? { minHeight: '100vh' } : {} }, this.renderFollowUpSideSheet(), index.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 })));
     }
@@ -1279,4 +1335,3 @@ const UdpFormsRenderer = class {
 };
 
 exports.udp_forms_renderer = UdpFormsRenderer;
-//# sourceMappingURL=udp-forms-renderer.entry.cjs.js.map