@ukiahinsure/a2ui-react-adapter 0.1.6 → 0.1.8

package/dist/index.js

@@ -29,6 +29,7 @@ var A2UIClientAdapter = class {
   #surfaceOrder = [];
   #structureBySurface = /* @__PURE__ */ new Map();
   #persistedListRowsByPath = /* @__PURE__ */ new Map();
+  #deletedListItemIdsByPath = /* @__PURE__ */ new Map();
   #version = 0;
   #lastSeq = 0;
   #disposed = false;
@@ -157,6 +158,7 @@ var A2UIClientAdapter = class {
     this.#surfaceOrder = [];
     this.#structureBySurface.clear();
     this.#persistedListRowsByPath.clear();
+    this.#deletedListItemIdsByPath.clear();
     previous.model.dispose();
     this.#notify();
   }
@@ -213,14 +215,23 @@ var A2UIClientAdapter = class {
     const rawMessages = envelope.kind === "snapshot" ? validated.data : mergePersistedListRowsIntoMessages(
       validated.data,
       envelope.surfaceId,
-      this.#persistedListRowsByPath
+      this.#persistedListRowsByPath,
+      this.#deletedListItemIdsByPath
     );
-    const nextStructure = updateSurfaceStructures(
+    const listAddFreeMessages = removeListAddActionMessages(
       rawMessages,
+      envelope.surfaceId
+    );
+    const actionCompleteMessages = ensureOptionalCoverageSkipActionMessages(
+      listAddFreeMessages,
+      envelope.surfaceId
+    );
+    const nextStructure = updateSurfaceStructures(
+      actionCompleteMessages,
       envelope.kind === "snapshot" ? /* @__PURE__ */ new Map() : cloneSurfaceStructures(this.#structureBySurface)
     );
     const messages = normalizeChoiceValuesInMessages(
-      rawMessages,
+      actionCompleteMessages,
       envelope.surfaceId,
       nextStructure.get(envelope.surfaceId)
     );
@@ -260,9 +271,11 @@ var A2UIClientAdapter = class {
     this.#structureBySurface = nextStructure;
     if (envelope.kind === "snapshot") {
       this.#persistedListRowsByPath.clear();
+      this.#deletedListItemIdsByPath.clear();
     }
     rememberPersistedListRows(
       this.#persistedListRowsByPath,
+      this.#deletedListItemIdsByPath,
       candidate.model.getSurface(envelope.surfaceId)?.dataModel.get("/")
     );
     previous.model.dispose();
@@ -290,11 +303,63 @@ var A2UIClientAdapter = class {
       sourceComponentId: action.sourceComponentId,
       context: { ...action.context }
     };
+    const submittedProviderRow = submittedProviderRowFromEvent(event);
+    if (submittedProviderRow !== void 0) {
+      this.#rememberSubmittedProviderRow(
+        event.surfaceId,
+        submittedProviderRow,
+        event.context
+      );
+    }
+    if (event.actionName === "flow.list.delete") {
+      this.#removeDeletedListRow(event.surfaceId, event.context);
+    }
     this.#options.onAction?.(event);
     for (const listener of this.#actionListeners) {
       listener(event);
     }
   }
+  #rememberSubmittedProviderRow(surfaceId, row, context) {
+    const rows = upsertListRow(
+      this.#persistedListRowsByPath.get("needs.providers") ?? [],
+      row
+    );
+    this.#persistedListRowsByPath.set("needs.providers", rows);
+    const surface = this.#processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      return;
+    }
+    surface.dataModel.set("/needs.providers", cloneJsonArray(rows));
+    surface.dataModel.set("/needs/providers", cloneJsonArray(rows));
+    clearSubmittedProviderDraft(surface.dataModel, context);
+    removeSubmittedProviderDraftControls(
+      surface.componentsModel.entries,
+      eventSourceFieldPaths(context),
+      context
+    );
+    this.#notify();
+  }
+  #removeDeletedListRow(surfaceId, context) {
+    const listPath = context.listPath;
+    const itemId = context.itemId;
+    if (typeof listPath !== "string" || listPath.length === 0 || typeof itemId !== "string" || itemId.length === 0) {
+      return;
+    }
+    const cachedRows = this.#persistedListRowsByPath.get(listPath) ?? [];
+    const nextRows = removeListRowByItemId(cachedRows, itemId);
+    this.#persistedListRowsByPath.set(listPath, nextRows);
+    rememberDeletedListItemId(this.#deletedListItemIdsByPath, listPath, itemId);
+    const surface = this.#processor.model.getSurface(surfaceId);
+    if (surface === void 0) {
+      return;
+    }
+    surface.dataModel.set(`/${listPath}`, cloneJsonArray(nextRows));
+    surface.dataModel.set(
+      `/${listPath.replaceAll(".", "/")}`,
+      cloneJsonArray(nextRows)
+    );
+    this.#notify();
+  }
   #snapshotMessages() {
     const messages = [];
     for (const surface of this.#processor.model.surfacesMap.values()) {
@@ -364,6 +429,254 @@ function cloneSurfaceStructures(source) {
     ])
   );
 }
+function ensureOptionalCoverageSkipActionMessages(messages, surfaceId) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!isRecord(message) || !isRecord(message.updateComponents)) {
+      continue;
+    }
+    const update = message.updateComponents;
+    if (update.surfaceId !== surfaceId || !Array.isArray(update.components)) {
+      continue;
+    }
+    const submit = update.components.find(
+      (component) => isRecord(component) && isNonEmptyString(component.id) && hasActionName(component, "flow.submit")
+    );
+    if (!isRecord(submit) || !isNonEmptyString(submit.id)) {
+      return messages;
+    }
+    const optionalCoverageField = optionalCoverageFieldName(
+      update.components,
+      submit.id
+    );
+    if (optionalCoverageField === void 0) {
+      continue;
+    }
+    const patchedSubmit = submitActionWithDefaultUnknown(
+      submit,
+      optionalCoverageField
+    );
+    const hasSkip = update.components.some(
+      (component) => hasActionName(component, "flow.skip")
+    );
+    if (hasSkip && patchedSubmit === submit) {
+      return messages;
+    }
+    if (hasSkip) {
+      const nextMessages2 = [...messages];
+      nextMessages2[index] = {
+        ...message,
+        updateComponents: {
+          ...update,
+          components: update.components.map(
+            (component) => component === submit ? patchedSubmit : component
+          )
+        }
+      };
+      return nextMessages2;
+    }
+    const parent = update.components.find(
+      (component) => isRecord(component) && Array.isArray(component.children) && component.children.includes(submit.id)
+    );
+    if (!isRecord(parent) || !Array.isArray(parent.children)) {
+      return messages;
+    }
+    const labelId = `${submit.id}:optional-skip-label`;
+    const buttonId = `${submit.id}:optional-skip`;
+    if (update.components.some(
+      (component) => isRecord(component) && (component.id === labelId || component.id === buttonId)
+    )) {
+      return messages;
+    }
+    const nextParent = {
+      ...parent,
+      children: parent.children.flatMap(
+        (child) => child === submit.id ? [buttonId, child] : [child]
+      )
+    };
+    const nextComponents = update.components.map(
+      (component) => component === parent ? nextParent : component === submit ? patchedSubmit : component
+    );
+    nextComponents.push(
+      {
+        id: labelId,
+        component: "Text",
+        text: "Skip"
+      },
+      {
+        id: buttonId,
+        component: "Button",
+        child: labelId,
+        action: {
+          event: {
+            name: "flow.submit",
+            context: { [optionalCoverageField]: "unknown" }
+          }
+        }
+      }
+    );
+    const nextMessages = [...messages];
+    nextMessages[index] = {
+      ...message,
+      updateComponents: {
+        ...update,
+        components: nextComponents
+      }
+    };
+    return nextMessages;
+  }
+  return messages;
+}
+function removeListAddActionMessages(messages, surfaceId) {
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (!isRecord(message) || !isRecord(message.updateComponents)) {
+      continue;
+    }
+    const update = message.updateComponents;
+    if (update.surfaceId !== surfaceId || !Array.isArray(update.components)) {
+      continue;
+    }
+    const addIds = listAddComponentIds(update.components);
+    if (addIds.size === 0) {
+      continue;
+    }
+    const nextMessages = [...messages];
+    nextMessages[index] = {
+      ...message,
+      updateComponents: {
+        ...update,
+        components: update.components.filter(
+          (component) => !(isRecord(component) && isNonEmptyString(component.id) && addIds.has(component.id))
+        ).map(
+          (component) => removeComponentChildren(component, addIds)
+        )
+      }
+    };
+    return nextMessages;
+  }
+  return messages;
+}
+function listAddComponentIds(components) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    if (!isRecord(component) || !isNonEmptyString(component.id) || !hasActionName(component, "flow.list.add")) {
+      continue;
+    }
+    ids.add(component.id);
+    const child = component.child;
+    if (typeof child === "string" && child.length > 0) {
+      ids.add(child);
+    }
+  }
+  return ids;
+}
+function removeComponentChildren(component, removedIds) {
+  if (!isRecord(component) || !Array.isArray(component.children)) {
+    return component;
+  }
+  const children = component.children.filter(
+    (child) => typeof child !== "string" || !removedIds.has(child)
+  );
+  return children.length === component.children.length ? component : { ...component, children };
+}
+function submitActionWithDefaultUnknown(submit, field) {
+  if (!isRecord(submit.action) || !isRecord(submit.action.event)) {
+    return submit;
+  }
+  const event = submit.action.event;
+  const context = isRecord(event.context) ? event.context : {};
+  if (Object.hasOwn(context, field)) {
+    return submit;
+  }
+  return {
+    ...submit,
+    action: {
+      ...submit.action,
+      event: {
+        ...event,
+        context: {
+          ...context,
+          [field]: "unknown"
+        }
+      }
+    }
+  };
+}
+function optionalCoverageFieldName(components, submitId) {
+  const statePrefix = componentStatePrefix(submitId);
+  if (statePrefix !== void 0) {
+    const stateField = optionalCoverageFieldFromFieldBindings(
+      components.filter(
+        (component) => isRecord(component) && isNonEmptyString(component.id) && component.id.startsWith(`${statePrefix}:`)
+      )
+    );
+    if (stateField !== void 0) {
+      return stateField;
+    }
+  }
+  const parent = components.find(
+    (component) => isRecord(component) && Array.isArray(component.children) && component.children.includes(submitId)
+  );
+  if (isRecord(parent) && Array.isArray(parent.children)) {
+    const childIds = new Set(parent.children.filter(isNonEmptyString));
+    const childField = optionalCoverageFieldFromFieldBindings(
+      components.filter(
+        (component) => isRecord(component) && isNonEmptyString(component.id) && childIds.has(component.id)
+      )
+    );
+    if (childField !== void 0) {
+      return childField;
+    }
+  }
+  return void 0;
+}
+function componentStatePrefix(componentId) {
+  const marker = ":action:";
+  const markerIndex = componentId.indexOf(marker);
+  if (markerIndex > 0) {
+    return componentId.slice(0, markerIndex);
+  }
+  const fallbackIndex = componentId.lastIndexOf(":");
+  return fallbackIndex > 0 ? componentId.slice(0, fallbackIndex) : void 0;
+}
+function optionalCoverageFieldFromFieldBindings(components) {
+  const normalized = components.flatMap((component) => componentFieldSearchText(component)).map(normalizeSearchText).join(" ");
+  if (normalized.includes("vatricarebenefits") || normalized.includes("coveragevatricarebenefits") || normalized.includes("tricareorchampvabenefits") || normalized.includes("vachampvabenefits")) {
+    return "va_tricare_benefits";
+  }
+  if (normalized.includes("employerunioncoverage") || normalized.includes("coverageemployerunioncoverage")) {
+    return "employer_union_coverage";
+  }
+  return void 0;
+}
+function componentFieldSearchText(component) {
+  if (!isRecord(component)) {
+    return [];
+  }
+  const values = [];
+  for (const key of ["label", "field"]) {
+    const value2 = component[key];
+    if (typeof value2 === "string") {
+      values.push(value2);
+    }
+  }
+  const value = component.value;
+  if (isRecord(value) && typeof value.path === "string") {
+    values.push(value.path);
+  }
+  return values;
+}
+function normalizeSearchText(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function hasActionName(component, actionName) {
+  if (!isRecord(component) || !isRecord(component.action)) {
+    return false;
+  }
+  const event = component.action.event;
+  return isRecord(event) && event.name === actionName;
+}
 function updateSurfaceStructures(messages, structures) {
   for (const message of messages) {
     if (!isRecord(message)) {
@@ -543,8 +856,8 @@ function fieldFromPointer(path) {
 function fieldPointer(field) {
   return `/${field.replaceAll("~", "~0").replaceAll("/", "~1")}`;
 }
-function mergePersistedListRowsIntoMessages(messages, surfaceId, persistedRowsByPath) {
-  if (persistedRowsByPath.size === 0) {
+function mergePersistedListRowsIntoMessages(messages, surfaceId, persistedRowsByPath, deletedItemIdsByPath) {
+  if (persistedRowsByPath.size === 0 && deletedItemIdsByPath.size === 0) {
     return [...messages];
   }
   let mergedRoot = false;
@@ -559,7 +872,8 @@ function mergePersistedListRowsIntoMessages(messages, surfaceId, persistedRowsBy
         ...message.updateDataModel,
         value: mergePersistedListRowsIntoRoot(
           message.updateDataModel.value,
-          persistedRowsByPath
+          persistedRowsByPath,
+          deletedItemIdsByPath
         )
       }
     };
@@ -574,46 +888,454 @@ function mergePersistedListRowsIntoMessages(messages, surfaceId, persistedRowsBy
       updateDataModel: {
         surfaceId,
         path: "/",
-        value: mergePersistedListRowsIntoRoot({}, persistedRowsByPath)
+        value: mergePersistedListRowsIntoRoot(
+          {},
+          persistedRowsByPath,
+          deletedItemIdsByPath
+        )
       }
     }
   ];
 }
-function mergePersistedListRowsIntoRoot(root, persistedRowsByPath) {
+function mergePersistedListRowsIntoRoot(root, persistedRowsByPath, deletedItemIdsByPath) {
   const merged = cloneJsonRecord(root);
-  const activeDraftListPaths = activeListDraftPaths(merged);
-  for (const [listPath, rows] of persistedRowsByPath) {
+  for (const listPath of /* @__PURE__ */ new Set([
+    ...persistedRowsByPath.keys(),
+    ...deletedItemIdsByPath.keys()
+  ])) {
+    const rows = persistedRowsByPath.get(listPath) ?? [];
     const dottedRows = merged[listPath];
     const nestedRows = getNestedValue(merged, listPath);
     const incomingRows = Array.isArray(dottedRows) ? dottedRows : Array.isArray(nestedRows) ? nestedRows : void 0;
-    const shouldPreserveCachedRows = rows.length > 0 && (incomingRows === void 0 || incomingRows.length === 0) && !activeDraftListPaths.has(listPath);
+    const shouldPreserveCachedRows = rows.length > 0 && (incomingRows === void 0 || incomingRows.length === 0 && (!hasListDraft(merged, listPath) || hasBlankListDraft(merged, listPath)));
     const effectiveRows = shouldPreserveCachedRows ? rows : incomingRows ?? rows;
-    if (!Array.isArray(dottedRows) || shouldPreserveCachedRows) {
-      merged[listPath] = cloneJsonArray(effectiveRows);
-    }
-    if (!Array.isArray(nestedRows) || shouldPreserveCachedRows) {
-      setNestedValue(merged, listPath, cloneJsonArray(effectiveRows));
-    }
+    const visibleRows = filterDeletedListRows(
+      effectiveRows,
+      deletedItemIdsByPath.get(listPath)
+    );
+    const normalizedRows = normalizeListRows(listPath, visibleRows, merged);
+    merged[listPath] = cloneJsonArray(normalizedRows);
+    setNestedValue(merged, listPath, cloneJsonArray(normalizedRows));
   }
   return merged;
 }
-function activeListDraftPaths(root) {
+function hasBlankListDraft(root, listPath) {
   const drafts = root.__listDrafts;
   if (!isRecord(drafts)) {
-    return /* @__PURE__ */ new Set();
+    return false;
   }
-  return new Set(
-    Object.keys(drafts).filter((listPath) => listPath.trim().length > 0)
-  );
+  const draft = drafts[listPath];
+  if (!isRecord(draft)) {
+    return false;
+  }
+  return Object.values(draft).every(isBlankDraftValue);
+}
+function hasListDraft(root, listPath) {
+  const drafts = root.__listDrafts;
+  return isRecord(drafts) && isRecord(drafts[listPath]);
+}
+function isBlankDraftValue(value) {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "string") {
+    return value.trim().length === 0;
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0 || value.every(isBlankDraftValue);
+  }
+  return false;
 }
-function rememberPersistedListRows(persistedRowsByPath, root) {
+function rememberPersistedListRows(persistedRowsByPath, deletedItemIdsByPath, root) {
   if (!isRecord(root)) {
     return;
   }
   for (const [listPath, rows] of listRowsFromRoot(root)) {
-    persistedRowsByPath.set(listPath, cloneJsonArray(rows));
+    const visibleRows = filterDeletedListRows(
+      rows,
+      deletedItemIdsByPath.get(listPath)
+    );
+    persistedRowsByPath.set(
+      listPath,
+      normalizeListRows(listPath, visibleRows, root)
+    );
   }
 }
+function normalizeListRows(listPath, rows, root) {
+  const clonedRows = cloneJsonArray(rows);
+  if (listPath !== "needs.providers") {
+    return clonedRows;
+  }
+  const rootProvider = root === void 0 ? void 0 : providerRowFromAliases(root);
+  if (clonedRows.length === 0 && rootProvider !== void 0) {
+    return [normalizeProviderRow(rootProvider)];
+  }
+  return clonedRows.map(
+    (row) => isRecord(row) ? normalizeProviderRow(row, rootProvider) : row
+  );
+}
+function normalizeProviderRow(row, fallback) {
+  const normalized = cloneJsonRecord(row);
+  const name = firstProviderName(normalized) ?? (fallback === void 0 ? void 0 : firstProviderName(fallback));
+  const location = firstProviderLocation(normalized) ?? (fallback === void 0 ? void 0 : firstProviderLocation(fallback));
+  if (normalized.primary_care_provider === void 0 && name !== void 0) {
+    normalized.primary_care_provider = name;
+  }
+  if (normalized.primary_care_provider_location === void 0 && location !== void 0) {
+    normalized.primary_care_provider_location = location;
+  }
+  if (name !== void 0 && location !== void 0 && typeof normalized.__displayText === "string" && !normalized.__displayText.includes(location)) {
+    normalized.__displayText = `${normalized.__displayText} | Provider Location: ${location}`;
+  } else if (normalized.__displayText === void 0 && (name !== void 0 || location !== void 0)) {
+    normalized.__displayText = [
+      name === void 0 ? void 0 : `Provider Name: ${name}`,
+      location === void 0 ? void 0 : `Provider Location: ${location}`
+    ].filter((part) => part !== void 0).join(" | ");
+  }
+  return normalized;
+}
+function providerRowFromAliases(source) {
+  const name = firstProviderName(source);
+  const location = firstProviderLocation(source);
+  if (name === void 0 && location === void 0) {
+    return void 0;
+  }
+  return {
+    itemId: "voice-primary-care-provider",
+    ...name === void 0 ? {} : { primary_care_provider: name },
+    ...location === void 0 ? {} : { primary_care_provider_location: location }
+  };
+}
+function submittedProviderRowFromEvent(event) {
+  if (event.actionName !== "flow.submit") {
+    return void 0;
+  }
+  const listPath = event.context.listPath;
+  if (listPath !== "needs.providers" && !hasProviderSubmitFields(event.context)) {
+    return void 0;
+  }
+  const name = firstProviderName(event.context);
+  const location = firstProviderLocation(event.context);
+  if (name === void 0 && location === void 0) {
+    return void 0;
+  }
+  return {
+    itemId: "submitted-primary-care-provider",
+    ...name === void 0 ? {} : { primary_care_provider: name },
+    ...location === void 0 ? {} : { primary_care_provider_location: location },
+    __displayText: [
+      name === void 0 ? void 0 : `Provider Name: ${name}`,
+      location === void 0 ? void 0 : `Provider Location: ${location}`
+    ].filter((part) => part !== void 0).join(" | ")
+  };
+}
+function clearSubmittedProviderDraft(dataModel, context) {
+  for (const key of Object.keys(context)) {
+    if (key === "listPath") {
+      continue;
+    }
+    if (firstTextField(context, [key]) === void 0 || !isProviderSubmitField(key)) {
+      continue;
+    }
+    dataModel.set(`/__listDrafts/needs.providers/${key}`, "");
+  }
+}
+function removeSubmittedProviderDraftControls(entries, fieldPaths, context) {
+  const components = [...entries];
+  const controlIds = /* @__PURE__ */ new Set();
+  for (const [id, component] of components) {
+    if (component.type === "Button" && isProviderSubmitButton(component, context)) {
+      controlIds.add(id);
+      const child = component.properties.child;
+      if (typeof child === "string") {
+        controlIds.add(child);
+      }
+      continue;
+    }
+    if (component.type !== "TextField") {
+      continue;
+    }
+    const value = component.properties.value;
+    const label = component.properties.label;
+    if (isRecord(value) && typeof value.path === "string" && (fieldPaths.has(value.path) || isProviderDraftFieldPath(value.path)) || typeof label === "string" && isProviderSubmitLabel(label)) {
+      controlIds.add(id);
+    }
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [id, component] of components) {
+      if (controlIds.has(id) || component.type === "Column") {
+        continue;
+      }
+      const children = component.properties.children;
+      if (Array.isArray(children) && children.length > 0 && children.every(
+        (child) => typeof child === "string" && controlIds.has(child)
+      )) {
+        controlIds.add(id);
+        changed = true;
+      }
+    }
+  }
+  for (const [, component] of components) {
+    const children = component.properties.children;
+    if (!Array.isArray(children)) {
+      continue;
+    }
+    const nextChildren = children.filter(
+      (child) => typeof child !== "string" || !controlIds.has(child)
+    );
+    if (nextChildren.length === children.length) {
+      continue;
+    }
+    component.properties = {
+      ...component.properties,
+      children: nextChildren
+    };
+  }
+}
+function isProviderSubmitButton(component, context) {
+  const action = component.properties.action;
+  if (!isRecord(action) || !isRecord(action.event)) {
+    return false;
+  }
+  const event = action.event;
+  return event.name === "flow.submit" && sameProviderSubmitContext(event.context, context);
+}
+function sameProviderSubmitContext(candidate, context) {
+  if (!isRecord(candidate) || candidate.listPath !== "needs.providers" && !hasProviderSubmitFields(candidate)) {
+    return false;
+  }
+  for (const key of Object.keys(context)) {
+    if (key === "listPath" || !isProviderSubmitField(key)) {
+      continue;
+    }
+    if (!(key in candidate)) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasProviderSubmitFields(context) {
+  return Object.keys(context).some(
+    (key) => key !== "listPath" && isProviderSubmitField(key)
+  );
+}
+function isProviderSubmitField(key) {
+  return (/* @__PURE__ */ new Set([
+    "primary_care_provider",
+    "primaryCareProvider",
+    "primary_provider",
+    "primaryProvider",
+    "primary_care_doctor",
+    "primaryCareDoctor",
+    "pcp",
+    "providerName",
+    "provider_name",
+    "displayName",
+    "display_name",
+    "doctorName",
+    "doctorname",
+    "doctor_name",
+    "name",
+    "primary_care_provider_location",
+    "primaryCareProviderLocation",
+    "provider_location",
+    "providerLocation",
+    "location_details",
+    "locationDetails",
+    "office_location",
+    "officeLocation",
+    "practice_location",
+    "practiceLocation",
+    "location",
+    "address"
+  ])).has(key);
+}
+function eventSourceFieldPaths(context) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const [key, value] of Object.entries(context)) {
+    if (key === "listPath" || !isProviderSubmitField(key) || !isRecord(value)) {
+      continue;
+    }
+    const path = value.path;
+    if (typeof path === "string") {
+      paths.add(path);
+    }
+  }
+  return paths;
+}
+function isProviderDraftFieldPath(path) {
+  const prefix = "/__listDrafts/needs.providers/";
+  const field = path.startsWith(prefix) ? path.slice(prefix.length) : lastPathSegment(path);
+  return field !== void 0 && isProviderSubmitField(field);
+}
+function lastPathSegment(path) {
+  const normalized = path.trim().replaceAll("\\", "/");
+  const index = normalized.lastIndexOf("/");
+  const segment = index >= 0 ? normalized.slice(index + 1) : normalized;
+  return segment.length > 0 ? segment : void 0;
+}
+function isProviderSubmitLabel(label) {
+  switch (normalizeFieldKey(label)) {
+    case "provider_name":
+    case "primary_care_provider":
+    case "primary_care_provider_name":
+    case "provider_location":
+    case "primary_care_provider_location":
+    case "location_details":
+      return true;
+    default:
+      return false;
+  }
+}
+function normalizeFieldKey(key) {
+  return key.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
+}
+function upsertListRow(rows, row) {
+  const itemId = row.itemId;
+  if (typeof itemId !== "string" || itemId.length === 0) {
+    return [...rows, row];
+  }
+  const next = [...rows];
+  const existing = next.findIndex(
+    (candidate) => isRecord(candidate) && candidate.itemId === itemId
+  );
+  if (existing >= 0) {
+    next[existing] = row;
+    return next;
+  }
+  return [...next, row];
+}
+function removeListRowByItemId(rows, itemId) {
+  return rows.filter(
+    (row) => !isRecord(row) || row.itemId !== itemId
+  );
+}
+function rememberDeletedListItemId(deletedItemIdsByPath, listPath, itemId) {
+  const deleted = deletedItemIdsByPath.get(listPath) ?? /* @__PURE__ */ new Set();
+  deleted.add(itemId);
+  deletedItemIdsByPath.set(listPath, deleted);
+}
+function filterDeletedListRows(rows, deletedItemIds) {
+  const clonedRows = cloneJsonArray(rows);
+  if (deletedItemIds === void 0 || deletedItemIds.size === 0) {
+    return clonedRows;
+  }
+  return clonedRows.filter(
+    (row) => !isRecord(row) || !deletedItemIds.has(stringRowItemId(row))
+  );
+}
+function stringRowItemId(row) {
+  const itemId = row.itemId;
+  return typeof itemId === "string" ? itemId : "";
+}
+var PROVIDER_NAME_FIELDS = /* @__PURE__ */ new Set([
+  "primary_care_provider",
+  "primarycareprovider",
+  "primary_care_provider_name",
+  "primarycareprovidername",
+  "primary_provider",
+  "primaryprovider",
+  "primary_provider_name",
+  "primaryprovidername",
+  "primary_care_doctor",
+  "primarycaredoctor",
+  "primary_care_doctor_name",
+  "primarycaredoctorname",
+  "pcp",
+  "pcp_name",
+  "pcpname",
+  "provider",
+  "provider_name",
+  "providername",
+  "display_name",
+  "displayname",
+  "doctor",
+  "doctor_name",
+  "doctorname",
+  "name"
+]);
+var PROVIDER_LOCATION_FIELDS = /* @__PURE__ */ new Set([
+  "primary_care_provider_location",
+  "primarycareproviderlocation",
+  "primary_provider_location",
+  "primaryproviderlocation",
+  "primary_care_location",
+  "primarycarelocation",
+  "primary_care_doctor_location",
+  "primarycaredoctorlocation",
+  "pcp_location",
+  "pcplocation",
+  "provider_location",
+  "providerlocation",
+  "provider_location_details",
+  "providerlocationdetails",
+  "doctor_location",
+  "doctorlocation",
+  "location",
+  "location_details",
+  "locationdetails",
+  "office_location",
+  "officelocation",
+  "practice_location",
+  "practicelocation",
+  "provider_address",
+  "provideraddress",
+  "doctor_address",
+  "doctoraddress",
+  "address",
+  "city_state",
+  "citystate"
+]);
+function firstProviderName(source) {
+  return firstTextByNormalizedField(source, PROVIDER_NAME_FIELDS);
+}
+function firstProviderLocation(source) {
+  return firstTextByNormalizedField(source, PROVIDER_LOCATION_FIELDS);
+}
+function firstTextByNormalizedField(source, fields) {
+  for (const [key, value] of Object.entries(source)) {
+    if (!fields.has(normalizeFieldKey(key))) {
+      continue;
+    }
+    const text = scalarText(value);
+    if (text !== void 0) {
+      return text;
+    }
+  }
+  return void 0;
+}
+function scalarText(value) {
+  if (typeof value === "string") {
+    const text = value.trim();
+    return text.length > 0 ? text : void 0;
+  }
+  if (!isRecord(value)) {
+    return void 0;
+  }
+  return firstTextField(value, [
+    "value",
+    "displayValue",
+    "display_value",
+    "text",
+    "answer",
+    "label"
+  ]);
+}
+function firstTextField(source, keys) {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value !== "string") {
+      continue;
+    }
+    const text = value.trim();
+    if (text.length > 0) {
+      return text;
+    }
+  }
+  return void 0;
+}
 function listRowsFromRoot(root) {
   const rowsByPath = /* @__PURE__ */ new Map();
   for (const [key, value] of Object.entries(root)) {
@@ -796,6 +1518,7 @@ function A2UISurfaceHost({
           resolvedSurfaceMetadata?.fieldInteractions ?? []
         ),
         annotateActionControls(root),
+        suppressSkipForMandatoryFields(root, structure.fields),
         blockInvalidActionControls(root),
         setPendingGroupsDisabled(
           root,
@@ -1113,7 +1836,9 @@ function annotateActionControls(root) {
   );
   const groups = /* @__PURE__ */ new Set();
   for (const action of actions) {
+    const label = action.textContent?.trim().toLowerCase() ?? "";
     action.dataset.a2uiAction = "true";
+    action.dataset.a2uiActionLabel = label;
     if (action.parentElement !== null) {
       action.parentElement.dataset.a2uiActionGroup = "true";
       groups.add(action.parentElement);
@@ -1122,12 +1847,40 @@ function annotateActionControls(root) {
   return () => {
     for (const action of actions) {
       delete action.dataset.a2uiAction;
+      delete action.dataset.a2uiActionLabel;
     }
     for (const group of groups) {
       delete group.dataset.a2uiActionGroup;
     }
   };
 }
+function suppressSkipForMandatoryFields(root, fields) {
+  const requiredFields = fields.filter((field) => field.required);
+  if (requiredFields.length === 0 || requiredFields.every((field) => isOptionalCoverageField(field.field))) {
+    return () => void 0;
+  }
+  const skipButtons = [
+    ...root.querySelectorAll("[data-a2ui-action='true']")
+  ].filter((button) => button.dataset.a2uiActionLabel === "skip");
+  const originals = skipButtons.map((button) => ({
+    button,
+    hidden: button.hidden,
+    ariaHidden: button.getAttribute("aria-hidden")
+  }));
+  for (const button of skipButtons) {
+    button.hidden = true;
+    button.setAttribute("aria-hidden", "true");
+  }
+  return () => {
+    for (const original of originals) {
+      original.button.hidden = original.hidden;
+      restoreAttribute(original.button, "aria-hidden", original.ariaHidden);
+    }
+  };
+}
+function isOptionalCoverageField(field) {
+  return field === "employer_union_coverage" || field === "va_tricare_benefits" || field === "coverage.employerUnionCoverage" || field === "coverage.vaTricareBenefits";
+}
 var EMPTY_STRUCTURE = { fields: [], tabs: [] };
 var SurfaceErrorBoundary = class extends Component {
   state = { failedSurfaceId: void 0 };
@@ -1236,8 +1989,22 @@ function applyControlValidationAttributes(control, field) {
 }
 function attachControlValidationBehavior(control, field) {
   const maxLength = numericMaxLengthForField(field);
+  const customValidation = customValidationForField(field);
   if (maxLength === void 0 || !isTextInput(control)) {
-    return void 0;
+    if (customValidation === void 0 || !isTextInput(control)) {
+      return void 0;
+    }
+    const validate = () => {
+      applyCustomValidationMessage(control, customValidation);
+    };
+    control.addEventListener("input", validate);
+    control.addEventListener("change", validate);
+    validate();
+    return () => {
+      control.setCustomValidity("");
+      control.removeEventListener("input", validate);
+      control.removeEventListener("change", validate);
+    };
   }
   const sanitize = () => {
     const next = control.value.replace(/\D/g, "").slice(0, maxLength);
@@ -1245,15 +2012,50 @@ function attachControlValidationBehavior(control, field) {
       control.value = next;
       control.dispatchEvent(new Event("input", { bubbles: true }));
     }
+    if (customValidation !== void 0) {
+      applyCustomValidationMessage(control, customValidation);
+    }
   };
   control.addEventListener("input", sanitize);
   control.addEventListener("change", sanitize);
   sanitize();
   return () => {
+    control.setCustomValidity("");
     control.removeEventListener("input", sanitize);
     control.removeEventListener("change", sanitize);
   };
 }
+function customValidationForField(field) {
+  if (isZipValidationRegexp(field.validationRegexp)) {
+    return {
+      message: "Enter a valid 5-digit ZIP code.",
+      pattern: regexpFromPattern(field.validationRegexp)
+    };
+  }
+  if (isPhoneValidationRegexp(field.validationRegexp)) {
+    return {
+      message: "Enter a valid 10-digit US phone number.",
+      pattern: regexpFromPattern(field.validationRegexp)
+    };
+  }
+  return void 0;
+}
+function applyCustomValidationMessage(control, validation) {
+  control.setCustomValidity("");
+  if (control.value.length > 0 && (validation.pattern?.test(control.value) === false || !control.checkValidity())) {
+    control.setCustomValidity(validation.message);
+  }
+}
+function regexpFromPattern(pattern) {
+  if (pattern === void 0) {
+    return void 0;
+  }
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return void 0;
+  }
+}
 function numericMaxLengthForField(field) {
   if (isPhoneValidationRegexp(field.validationRegexp)) {
     return 10;
@@ -1288,6 +2090,9 @@ function blockInvalidActionControls(root) {
     if (action === null || !root.contains(action)) {
       return;
     }
+    if (action.dataset.a2uiActionLabel === "skip") {
+      return;
+    }
     const invalid2 = firstInvalidInput(root);
     if (invalid2 === void 0) {
       return;
@@ -1985,7 +2790,7 @@ function decodeRendererAction(event) {
     const listPath = event.context.listPath;
     if (typeof listPath === "string" && listPath.length > 0) {
       const fieldEntries2 = entries.filter(([key]) => key !== "listPath");
-      const fields3 = scalarFields(fieldEntries2);
+      const fields3 = scalarFields(fieldEntries2, listPath);
       if (fields3 === null) {
         return null;
       }
@@ -2015,7 +2820,8 @@ function decodeRendererAction(event) {
     const fieldEntries2 = entries.filter(
       ([key]) => key !== "listPath" && key !== "itemId"
     );
-    const fields2 = scalarFields(fieldEntries2);
+    const fields2 = scalarFields(fieldEntries2, listPath);
+    const targetStateId2 = listActionTargetStateId(event.sourceComponentId);
     if (action !== "flow.list.delete" && (fields2 === null || Object.keys(fields2).length === 0)) {
       return null;
     }
@@ -2023,6 +2829,7 @@ function decodeRendererAction(event) {
       action,
       payload: {
         listPath,
+        ...targetStateId2 === void 0 ? {} : { targetStateId: targetStateId2 },
         ...typeof itemId === "string" ? { itemId } : {},
         ...fields2 !== null && Object.keys(fields2).length > 0 ? { fields: fields2 } : {}
       }
@@ -2045,17 +2852,77 @@ function decodeRendererAction(event) {
     }
   };
 }
-function scalarFields(entries) {
+function listActionTargetStateId(sourceComponentId) {
+  const markerIndex = sourceComponentId.indexOf(":list");
+  if (markerIndex <= 0) {
+    return void 0;
+  }
+  const stateId = sourceComponentId.slice(0, markerIndex);
+  return stateId.length > 0 ? stateId : void 0;
+}
+function scalarFields(entries, listPath) {
   const fields = {};
   for (const [key, value] of entries) {
     const normalized = normalizeFieldValue(value);
     if (normalized === void 0) {
       return null;
     }
-    fields[key] = normalized;
+    fields[canonicalListFieldKey(listPath, key)] = normalized;
   }
   return fields;
 }
+function canonicalListFieldKey(listPath, key) {
+  if (listPath !== "needs.providers") {
+    return key;
+  }
+  switch (normalizeFieldKey2(key)) {
+    case "primary_care_provider":
+    case "primarycareprovider":
+    case "primarycare":
+    case "primary_care":
+    case "primary_care_doctor":
+    case "primary_doctor":
+    case "primarydoctor":
+    case "primary_provider":
+    case "primaryprovider":
+    case "pcp":
+    case "provider_name":
+    case "providername":
+    case "display_name":
+    case "displayname":
+      return "primary_care_provider";
+    case "primary_care_provider_location":
+    case "primarycareproviderlocation":
+    case "primarycarelocation":
+    case "primary_care_location":
+    case "provider_location":
+    case "providerlocation":
+    case "doctor_location":
+    case "doctorlocation":
+    case "doctor_address":
+    case "doctoraddress":
+    case "location_details":
+    case "locationdetails":
+    case "provider_address":
+    case "provideraddress":
+    case "office_location":
+    case "officelocation":
+    case "practice_location":
+    case "practicelocation":
+    case "city":
+    case "city_state":
+    case "cityandstate":
+    case "city_and_state":
+    case "location":
+    case "address":
+      return "primary_care_provider_location";
+    default:
+      return key;
+  }
+}
+function normalizeFieldKey2(key) {
+  return key.trim().toLowerCase().replaceAll(/[^a-z0-9]+/g, "_").replaceAll(/^_+|_+$/g, "");
+}
 function isSameLogicalAction(envelope, candidate) {
   return envelope.action === candidate.action && JSON.stringify(envelope.payload) === JSON.stringify(candidate.payload);
 }