@redrockswebdevelopment/formstack-form-testing 0.1.19 → 0.1.21

package/dist/index.js

@@ -3242,6 +3242,7 @@ export async function answerProgressiveLiveFormField(page, options) {
         },
         ...(options.fieldKind ? { fieldKind: options.fieldKind } : {}),
         waitForEvent: options.waitForEvent ?? true,
+        dispatchDomEvents: options.dispatchDomEvents ?? "auto",
         afterQuiet: options.afterQuiet ?? true,
         ...(validationOptions ? { afterValidation: validationOptions } : {}),
     });
@@ -3384,7 +3385,7 @@ export function createLiveFormSampleFillPlan(definition, sampleValues, options =
         const entry = {
             key,
             target,
-            value: samples[key],
+            value: normalizeLiveFormSampleValue(config.kind, samples[key]),
             ...(config.kind === undefined ? {} : { fieldKind: config.kind }),
             ...(config.required === undefined ? {} : { required: config.required }),
         };
@@ -3430,6 +3431,41 @@ function createSampleSmokeReadinessOptions(definition, options, defaultEnabled)
     }
     return createLiveFormReadinessOptions(definition, { ...options, requiredOnly: true });
 }
+function stableSerializeLiveFormValue(value) {
+    if (value === undefined)
+        return "undefined";
+    const normalize = (entry) => {
+        if (Array.isArray(entry))
+            return entry.map(normalize);
+        if (entry && typeof entry === "object") {
+            return Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, normalize(child)]));
+        }
+        return entry;
+    };
+    return JSON.stringify(normalize(value));
+}
+export function normalizeLiveFormSampleValue(kind = "unknown", value) {
+    if (value instanceof Date)
+        return value.toISOString().slice(0, 10);
+    if (["radio", "rating", "select"].includes(kind) && typeof value === "string") {
+        return { value };
+    }
+    if (kind === "checkbox" && Array.isArray(value)) {
+        return { values: value };
+    }
+    if (kind === "checkbox" && typeof value === "boolean") {
+        return { checked: value };
+    }
+    return value;
+}
+export function createLiveFormFieldValueAdapter(kind = "unknown") {
+    return {
+        kind,
+        normalize: (value) => normalizeLiveFormSampleValue(kind, value),
+        isEmpty: (value) => isLiveFormFieldValueEmpty(normalizeLiveFormSampleValue(kind, value)),
+        equals: (actual, expected) => stableSerializeLiveFormValue(normalizeLiveFormSampleValue(kind, actual)) === stableSerializeLiveFormValue(normalizeLiveFormSampleValue(kind, expected)),
+    };
+}
 export async function runLiveFormSampleSmoke(page, definition, sampleValues, options = {}) {
     const beforeReadinessOptions = createSampleSmokeReadinessOptions(definition, options.beforeReadiness, false);
     const afterReadinessOptions = createSampleSmokeReadinessOptions(definition, options.afterReadiness, true);
@@ -3454,6 +3490,546 @@ export async function runLiveFormSampleSmoke(page, definition, sampleValues, opt
         ok: (quiet?.quiet ?? true) && (afterReadiness?.isReady ?? true) && ((validation?.inlineErrors.length ?? 0) === 0) && !(coverage?.hasUnknownFields ?? false),
     };
 }
+function sampleValueShapeIssue(key, kind, value) {
+    const normalizedValue = normalizeLiveFormSampleValue(kind, value);
+    const objectValue = value && typeof value === "object" ? value : null;
+    const normalizedObjectValue = normalizedValue && typeof normalizedValue === "object" ? normalizedValue : null;
+    if (["radio", "select", "rating"].includes(kind ?? "") && (normalizedObjectValue === null || typeof normalizedObjectValue.value !== "string")) {
+        return {
+            kind: "invalid-value-shape",
+            key,
+            message: `Sample value for ${key} should be an object with a string value property.`,
+            detail: { kind },
+        };
+    }
+    if (["checkbox", "matrix"].includes(kind ?? "") && normalizedObjectValue === null) {
+        return {
+            kind: "invalid-value-shape",
+            key,
+            message: `Sample value for ${key} should be an object payload for ${kind} fields.`,
+            detail: { kind },
+        };
+    }
+    if (kind === "name" && objectValue === null) {
+        return {
+            kind: "invalid-value-shape",
+            key,
+            message: `Sample value for ${key} should be an object with name subfields.`,
+            detail: { kind },
+        };
+    }
+    return null;
+}
+export function validateLiveFormSampleProfile(definition, sampleValues, options = {}) {
+    const samples = sampleValues;
+    const issues = [];
+    const unknownKeys = [];
+    const missingRequiredKeys = [];
+    const duplicateTargetKeys = [];
+    const targetOwners = new Map();
+    for (const key of Object.keys(samples)) {
+        if (!(key in definition)) {
+            unknownKeys.push(key);
+            issues.push({ kind: "unknown-sample-key", key, message: `Sample value key "${key}" does not exist in the field definition.` });
+        }
+    }
+    for (const [key, config] of Object.entries(definition)) {
+        const target = targetFromHandleConfig(config);
+        const targetKey = liveFormFieldTargetKey(target);
+        if (targetKey) {
+            const owner = targetOwners.get(targetKey);
+            if (owner && Object.hasOwn(samples, key) && Object.hasOwn(samples, owner) && options.allowDuplicateTargets !== true) {
+                duplicateTargetKeys.push(key);
+                issues.push({
+                    kind: "duplicate-target",
+                    key,
+                    target,
+                    message: `Sample value key "${key}" points to the same generated target as "${owner}".`,
+                    detail: { originalKey: owner },
+                });
+            }
+            else if (!owner) {
+                targetOwners.set(targetKey, key);
+            }
+        }
+        if (config.required === true && !Object.hasOwn(samples, key)) {
+            missingRequiredKeys.push(key);
+            issues.push({ kind: "missing-required-sample", key, target, message: `Required field "${key}" does not have a sample value.` });
+        }
+        if (!Object.hasOwn(samples, key))
+            continue;
+        if (options.requiredOnly === true && config.required !== true)
+            continue;
+        const value = normalizeLiveFormSampleValue(config.kind, samples[key]);
+        const shapeIssue = sampleValueShapeIssue(key, config.kind, value);
+        if (shapeIssue)
+            issues.push({ ...shapeIssue, target });
+        const allowedValues = options.optionValues?.[key];
+        if (!allowedValues || !value || typeof value !== "object")
+            continue;
+        const valueObject = value;
+        if (typeof valueObject.value === "string" && !allowedValues.includes(valueObject.value)) {
+            issues.push({
+                kind: "invalid-option-value",
+                key,
+                target,
+                message: `Sample value "${valueObject.value}" is not in the allowed option values for "${key}".`,
+                detail: { allowedValues },
+            });
+        }
+        if (Array.isArray(valueObject.values)) {
+            const invalid = valueObject.values.filter((entry) => typeof entry === "string" && !allowedValues.includes(entry));
+            if (invalid.length > 0) {
+                issues.push({
+                    kind: "invalid-option-values",
+                    key,
+                    target,
+                    message: `Sample values for "${key}" include values outside the allowed options: ${invalid.join(", ")}.`,
+                    detail: { allowedValues, invalid },
+                });
+            }
+        }
+    }
+    return {
+        issues,
+        unknownKeys,
+        missingRequiredKeys,
+        duplicateTargetKeys,
+        ok: issues.length === 0,
+    };
+}
+export function createLiveFormProgressiveSamplePlan(definition, sampleValues, options = {}) {
+    const basePlan = createLiveFormSampleFillPlan(definition, sampleValues, options);
+    const configuredSteps = new Map((options.steps ?? []).map((step) => [step.key, step]));
+    const orderedKeys = options.steps?.map((step) => step.key) ?? basePlan.map((entry) => entry.key);
+    const baseByKey = new Map(basePlan.map((entry) => [entry.key, entry]));
+    const plan = [];
+    for (const key of orderedKeys) {
+        const base = baseByKey.get(key);
+        if (!base)
+            continue;
+        const step = configuredSteps.get(key);
+        plan.push({
+            ...base,
+            ...(step?.expectVisibleAfter === undefined ? {} : { expectVisibleAfter: step.expectVisibleAfter }),
+            ...(step?.expectHiddenAfter === undefined ? {} : { expectHiddenAfter: step.expectHiddenAfter }),
+            ...(step?.expectResetAfter === undefined ? {} : { expectResetAfter: step.expectResetAfter }),
+            ...(step?.continueSelector === undefined ? {} : { continueSelector: step.continueSelector }),
+            ...(step?.expectVisibleAfterContinue === undefined ? {} : { expectVisibleAfterContinue: step.expectVisibleAfterContinue }),
+            ...(step?.expectHiddenAfterContinue === undefined ? {} : { expectHiddenAfterContinue: step.expectHiddenAfterContinue }),
+            ...(step?.transaction === undefined ? {} : { transaction: step.transaction }),
+        });
+    }
+    return plan;
+}
+export async function runLiveFormProgressiveSampleFlow(page, definition, sampleValues, options = {}) {
+    const plan = createLiveFormProgressiveSamplePlan(definition, sampleValues, options);
+    const answers = [];
+    for (const step of plan) {
+        answers.push(await answerProgressiveLiveFormField(page, {
+            ...(options.defaultTransaction ?? {}),
+            ...(step.transaction ?? {}),
+            target: step.target,
+            value: step.value,
+            ...(step.fieldKind === undefined ? {} : { fieldKind: step.fieldKind }),
+            ...(step.expectVisibleAfter === undefined ? {} : { expectVisible: step.expectVisibleAfter.map((target) => ({ ...target, visible: true })) }),
+            ...(step.expectHiddenAfter === undefined ? {} : { expectHidden: step.expectHiddenAfter }),
+            ...(step.expectResetAfter === undefined ? {} : { expectReset: step.expectResetAfter }),
+        }));
+        if (step.continueSelector) {
+            await page.locator(step.continueSelector).first().click();
+            const continueVisibilityTargets = [
+                ...(step.expectVisibleAfterContinue ?? []).map((target) => ({ ...target, visible: true })),
+                ...(step.expectHiddenAfterContinue ?? []).map((target) => ({ ...target, visible: false })),
+            ];
+            if (continueVisibilityTargets.length > 0) {
+                const visibility = await waitForLiveFormVisibility(page, { targets: continueVisibilityTargets });
+                if (!visibility.matched) {
+                    throw new Error(`Progressive step "${step.key}" continue action did not settle into the requested visibility state.`);
+                }
+            }
+        }
+    }
+    const quietOptions = options.afterQuiet === false ? undefined : options.afterQuiet === true ? {} : options.afterQuiet;
+    const readinessOptions = createSampleSmokeReadinessOptions(definition, options.afterReadiness, false);
+    const validationOptions = options.afterValidation === false ? undefined : options.afterValidation === true ? { expectNoErrors: true } : options.afterValidation;
+    const quiet = quietOptions ? await waitForLiveFormQuiet(page, quietOptions) : undefined;
+    const readiness = readinessOptions ? await waitForLiveFormReady(page, readinessOptions) : undefined;
+    const validation = validationOptions ? await waitForLiveFormValidationSettled(page, validationOptions) : undefined;
+    return {
+        plan,
+        answers,
+        ...(quiet ? { quiet } : {}),
+        ...(readiness ? { readiness } : {}),
+        ...(validation ? { validation } : {}),
+        ok: answers.every((answer) => (answer.visibility?.matched ?? true) &&
+            answer.resetValues.every((value) => value.valueMatched !== false) &&
+            ((answer.validation?.inlineErrors.length ?? 0) === 0)) && (quiet?.quiet ?? true) && (readiness?.isReady ?? true) && ((validation?.inlineErrors.length ?? 0) === 0),
+    };
+}
+export async function diagnoseLiveFormSubmitGate(page, options = {}) {
+    if (!hasEvaluate(page)) {
+        throw new Error("diagnoseLiveFormSubmitGate requires a Playwright page with evaluate().");
+    }
+    const selector = options.selector ?? ".fsSubmitButton, [type=submit], .fsSubmit";
+    const dom = await page.evaluate((submitSelector) => {
+        const element = document.querySelector(submitSelector);
+        if (!(element instanceof HTMLElement)) {
+            return {
+                exists: false,
+                visible: null,
+                disabled: null,
+                ariaDisabled: null,
+                dataReady: null,
+                hiddenReason: "missing",
+            };
+        }
+        const style = getComputedStyle(element);
+        const rect = element.getBoundingClientRect();
+        const disabled = "disabled" in element ? Boolean(element.disabled) : element.getAttribute("disabled") !== null;
+        const ariaDisabled = element.getAttribute("aria-disabled") === "true";
+        const dataReady = element.getAttribute("data-chat-submit-ready") ?? element.getAttribute("data-submit-ready");
+        const visible = style.display !== "none" && style.visibility !== "hidden" && Number(style.opacity) !== 0 && rect.width > 0 && rect.height > 0;
+        const hiddenReason = visible ? null : style.display === "none" ? "display-none" : style.visibility === "hidden" ? "visibility-hidden" : rect.width <= 0 || rect.height <= 0 ? "zero-size" : "transparent";
+        return { exists: true, visible, disabled, ariaDisabled, dataReady, hiddenReason };
+    }, selector);
+    const readiness = options.readiness ? await readLiveFormReadiness(page, options.readiness) : undefined;
+    const validation = options.validation ? await readLiveFormValidationState(page, typeof options.validation === "object" ? options.validation : {}) : undefined;
+    const blockingReasons = [];
+    if (!dom.exists)
+        blockingReasons.push("submit-control-missing");
+    if (dom.visible === false)
+        blockingReasons.push(`submit-control-hidden:${dom.hiddenReason ?? "unknown"}`);
+    if (dom.disabled === true)
+        blockingReasons.push("submit-control-disabled");
+    if (dom.ariaDisabled === true)
+        blockingReasons.push("submit-control-aria-disabled");
+    if (dom.dataReady === "false")
+        blockingReasons.push("submit-control-data-ready-false");
+    if (readiness && !readiness.isReady)
+        blockingReasons.push(`readiness-blocking-fields:${readiness.blockingFieldCount}`);
+    if (validation && validation.inlineErrors.length > 0)
+        blockingReasons.push(`validation-errors:${validation.inlineErrors.length}`);
+    const blockingFields = readiness?.fields.filter((field) => field.isBlocking) ?? [];
+    const validationErrors = validation?.inlineErrors ?? [];
+    return {
+        selector,
+        ...dom,
+        blockingReasons,
+        blockingFields,
+        validationErrors,
+        ...(readiness ? { readiness } : {}),
+        ...(validation ? { validation } : {}),
+        ready: blockingReasons.length === 0,
+    };
+}
+export async function diagnoseLiveFormLayout(page, options = {}) {
+    if (!hasEvaluate(page)) {
+        throw new Error("diagnoseLiveFormLayout requires a Playwright page with evaluate().");
+    }
+    return page.evaluate((layoutOptions) => {
+        const rootSelector = layoutOptions.rootSelector ?? "body";
+        const minTapTargetPx = layoutOptions.minTapTargetPx ?? 44;
+        const root = document.querySelector(rootSelector);
+        const viewportWidth = document.documentElement.clientWidth;
+        const bodyScrollWidth = document.documentElement.scrollWidth;
+        const rootScrollWidth = root instanceof HTMLElement ? root.scrollWidth : null;
+        const rootClientWidth = root instanceof HTMLElement ? root.clientWidth : null;
+        const issues = [];
+        if (bodyScrollWidth > viewportWidth + 1) {
+            issues.push({
+                kind: "horizontal-overflow",
+                selector: "html",
+                message: `Document scroll width ${bodyScrollWidth}px exceeds viewport width ${viewportWidth}px.`,
+                detail: { bodyScrollWidth, viewportWidth },
+            });
+        }
+        if (rootScrollWidth !== null && rootClientWidth !== null && rootScrollWidth > rootClientWidth + 1) {
+            issues.push({
+                kind: "horizontal-overflow",
+                selector: rootSelector,
+                message: `Root scroll width ${rootScrollWidth}px exceeds client width ${rootClientWidth}px.`,
+                detail: { rootScrollWidth, rootClientWidth },
+            });
+        }
+        const scrollCandidates = Array.from(document.querySelectorAll(layoutOptions.includeSelectors?.join(",") ?? `${rootSelector} *`));
+        for (const element of scrollCandidates) {
+            if (!(element instanceof HTMLElement))
+                continue;
+            const style = getComputedStyle(element);
+            const rect = element.getBoundingClientRect();
+            const selector = element.id ? `#${CSS.escape(element.id)}` : element.getAttribute("data-internal-label") ? `[data-internal-label="${CSS.escape(element.getAttribute("data-internal-label") ?? "")}"]` : element.tagName.toLowerCase();
+            if ((style.overflowY === "auto" || style.overflowY === "scroll") && element.scrollHeight > element.clientHeight + 1) {
+                issues.push({
+                    kind: "nested-scroll",
+                    selector,
+                    message: "Element has internal vertical scrolling.",
+                    detail: { scrollHeight: element.scrollHeight, clientHeight: element.clientHeight },
+                });
+            }
+            if (["BUTTON", "A", "INPUT", "SELECT", "TEXTAREA"].includes(element.tagName) && rect.width > 0 && rect.height > 0 && (rect.width < minTapTargetPx || rect.height < minTapTargetPx)) {
+                issues.push({
+                    kind: "small-tap-target",
+                    selector,
+                    message: `Tap target is smaller than ${minTapTargetPx}px.`,
+                    detail: { width: Math.round(rect.width), height: Math.round(rect.height), minTapTargetPx },
+                });
+            }
+        }
+        return {
+            rootSelector,
+            viewportWidth,
+            bodyScrollWidth,
+            rootScrollWidth,
+            rootClientWidth,
+            issues,
+            hasHorizontalOverflow: issues.some((issue) => issue.kind === "horizontal-overflow"),
+            hasNestedScroll: issues.some((issue) => issue.kind === "nested-scroll"),
+            hasSmallTapTargets: issues.some((issue) => issue.kind === "small-tap-target"),
+            ok: issues.length === 0,
+        };
+    }, options);
+}
+export async function diagnoseLiveFormIframeLayout(page, options) {
+    if (!hasEvaluate(page)) {
+        throw new Error("diagnoseLiveFormIframeLayout requires a Playwright page with evaluate().");
+    }
+    return page.evaluate((layoutOptions) => {
+        const iframe = document.querySelector(layoutOptions.iframeSelector);
+        const viewportWidth = document.documentElement.clientWidth;
+        const viewportHeight = document.documentElement.clientHeight;
+        const issues = [];
+        if (!(iframe instanceof HTMLElement)) {
+            return {
+                iframeSelector: layoutOptions.iframeSelector,
+                exists: false,
+                viewportWidth,
+                viewportHeight,
+                rect: null,
+                issues: [{
+                        kind: "horizontal-overflow",
+                        selector: layoutOptions.iframeSelector,
+                        message: "Iframe element was not found.",
+                    }],
+                ok: false,
+            };
+        }
+        const rect = iframe.getBoundingClientRect();
+        if (rect.left < -1 || rect.right > viewportWidth + 1) {
+            issues.push({
+                kind: "horizontal-overflow",
+                selector: layoutOptions.iframeSelector,
+                message: "Iframe extends outside the viewport horizontally.",
+                detail: { left: Math.round(rect.left), right: Math.round(rect.right), viewportWidth },
+            });
+        }
+        if (layoutOptions.expectedMaxWidth !== undefined && rect.width > layoutOptions.expectedMaxWidth + 1) {
+            issues.push({
+                kind: "horizontal-overflow",
+                selector: layoutOptions.iframeSelector,
+                message: `Iframe width ${Math.round(rect.width)}px exceeds expected maximum ${layoutOptions.expectedMaxWidth}px.`,
+                detail: { width: Math.round(rect.width), expectedMaxWidth: layoutOptions.expectedMaxWidth },
+            });
+        }
+        if (layoutOptions.expectedMaxHeight !== undefined && rect.height > layoutOptions.expectedMaxHeight + 1) {
+            issues.push({
+                kind: "nested-scroll",
+                selector: layoutOptions.iframeSelector,
+                message: `Iframe height ${Math.round(rect.height)}px exceeds expected maximum ${layoutOptions.expectedMaxHeight}px.`,
+                detail: { height: Math.round(rect.height), expectedMaxHeight: layoutOptions.expectedMaxHeight },
+            });
+        }
+        return {
+            iframeSelector: layoutOptions.iframeSelector,
+            exists: true,
+            viewportWidth,
+            viewportHeight,
+            rect: { width: Math.round(rect.width), height: Math.round(rect.height), top: Math.round(rect.top), left: Math.round(rect.left) },
+            issues,
+            ok: issues.length === 0,
+        };
+    }, options);
+}
+function endCascadePhase(name, startedAt, ok) {
+    const endedAt = Date.now();
+    return { name, startedAt, endedAt, durationMs: endedAt - startedAt, ok };
+}
+export async function assertLiveFormChangeCascade(page, options) {
+    const transaction = await performLiveFormFieldTransaction(page, {
+        ...(options.trigger.transaction ?? {}),
+        write: {
+            ...(options.trigger.write ?? {}),
+            target: options.trigger.target,
+            value: options.trigger.value,
+            notify: options.trigger.write?.notify ?? true,
+        },
+        ...(options.trigger.fieldKind === undefined ? {} : { fieldKind: options.trigger.fieldKind }),
+    });
+    const values = [];
+    for (const expected of options.expectValues ?? []) {
+        values.push(await waitForLiveFormFieldValue(page, expected));
+    }
+    const visibilityTargets = [
+        ...(options.expectVisible ?? []).map((target) => ({ ...target, visible: true })),
+        ...(options.expectHidden ?? []).map((target) => ({ ...target, visible: false })),
+    ];
+    const settled = await waitForLiveFormLogicSettled(page, {
+        quiet: options.quiet ?? false,
+        ...(visibilityTargets.length === 0 ? {} : { visibility: { targets: visibilityTargets } }),
+        ...(options.validation === undefined ? {} : { validation: options.validation }),
+    });
+    if (!settled.settled || values.some((value) => value.valueMatched === false)) {
+        throw new Error("Expected live form change cascade did not settle into the requested state.");
+    }
+    return { transaction, values, settled };
+}
+export async function traceLiveFormChangeCascade(page, options) {
+    const totalStartedAt = Date.now();
+    const phases = [];
+    const writeStartedAt = Date.now();
+    const transaction = await performLiveFormFieldTransaction(page, {
+        ...(options.trigger.transaction ?? {}),
+        write: {
+            ...(options.trigger.write ?? {}),
+            target: options.trigger.target,
+            value: options.trigger.value,
+            notify: options.trigger.write?.notify ?? true,
+        },
+        ...(options.trigger.fieldKind === undefined ? {} : { fieldKind: options.trigger.fieldKind }),
+    });
+    phases.push(endCascadePhase("write", writeStartedAt, transaction.write.valueMatched !== false));
+    const values = [];
+    const valuesStartedAt = Date.now();
+    for (const expected of options.expectValues ?? []) {
+        values.push(await waitForLiveFormFieldValue(page, expected));
+    }
+    phases.push(endCascadePhase("values", valuesStartedAt, values.every((value) => value.valueMatched !== false)));
+    const visibilityTargets = [
+        ...(options.expectVisible ?? []).map((target) => ({ ...target, visible: true })),
+        ...(options.expectHidden ?? []).map((target) => ({ ...target, visible: false })),
+    ];
+    const settleStartedAt = Date.now();
+    const settled = await waitForLiveFormLogicSettled(page, {
+        quiet: options.quiet ?? false,
+        ...(visibilityTargets.length === 0 ? {} : { visibility: { targets: visibilityTargets } }),
+        ...(options.validation === undefined ? {} : { validation: options.validation }),
+    });
+    phases.push(endCascadePhase("settled", settleStartedAt, settled.settled));
+    if (!settled.settled || values.some((value) => value.valueMatched === false)) {
+        throw new Error("Expected live form change cascade did not settle into the requested state.");
+    }
+    const endedAt = Date.now();
+    return {
+        label: options.label ?? "live-form-change-cascade",
+        transaction,
+        values,
+        settled,
+        phases,
+        totalMs: endedAt - totalStartedAt,
+    };
+}
+export async function runLiveFormRapidFieldChangeSequence(page, options) {
+    const transactions = [];
+    for (const write of options.writes) {
+        transactions.push(await performLiveFormFieldTransaction(page, {
+            ...(write.transaction ?? {}),
+            write: {
+                ...(write.write ?? {}),
+                target: write.target,
+                value: write.value,
+                notify: write.write?.notify ?? true,
+            },
+            ...(write.fieldKind === undefined ? {} : { fieldKind: write.fieldKind }),
+        }));
+    }
+    const quietOptions = options.afterQuiet === false ? undefined : options.afterQuiet === true ? {} : options.afterQuiet;
+    const validationOptions = options.afterValidation === false ? undefined : options.afterValidation === true ? { expectNoErrors: true } : options.afterValidation;
+    const quiet = quietOptions ? await waitForLiveFormQuiet(page, quietOptions) : undefined;
+    const validation = validationOptions ? await waitForLiveFormValidationSettled(page, validationOptions) : undefined;
+    const finalByTarget = new Map();
+    for (const write of options.writes) {
+        finalByTarget.set(liveFormFieldTargetKey(write.target) ?? JSON.stringify(write.target), { target: write.target, value: write.value });
+    }
+    const finalValues = [];
+    for (const expected of finalByTarget.values()) {
+        finalValues.push(await waitForLiveFormFieldValue(page, { target: expected.target, expectedValue: expected.value }));
+    }
+    return {
+        transactions,
+        ...(quiet ? { quiet } : {}),
+        ...(validation ? { validation } : {}),
+        finalValues,
+        ok: transactions.every((transaction) => transaction.write.valueMatched !== false) &&
+            (quiet?.quiet ?? true) &&
+            ((validation?.inlineErrors.length ?? 0) === 0) &&
+            finalValues.every((value) => value.valueMatched !== false),
+    };
+}
+export async function waitForLiveFormRerenderSettled(page, options = {}) {
+    if (!hasEvaluate(page)) {
+        throw new Error("waitForLiveFormRerenderSettled requires a Playwright page with evaluate().");
+    }
+    return page.evaluate((rerenderOptions) => new Promise((resolve) => {
+        const rootSelector = rerenderOptions.rootSelector ?? "body";
+        const root = document.querySelector(rootSelector);
+        const startedAt = Date.now();
+        const quietMs = rerenderOptions.quietMs ?? 150;
+        const timeoutMs = rerenderOptions.timeoutMs ?? 2000;
+        let mutationCount = 0;
+        let quietTimer;
+        let timeoutTimer;
+        let observer;
+        const finish = (quiet) => {
+            if (observer)
+                observer.disconnect();
+            if (quietTimer !== undefined)
+                window.clearTimeout(quietTimer);
+            if (timeoutTimer !== undefined)
+                window.clearTimeout(timeoutTimer);
+            const elapsedMs = Date.now() - startedAt;
+            resolve({
+                rootSelector,
+                mutationCount,
+                elapsedMs,
+                quiet,
+                ok: quiet && mutationCount >= (rerenderOptions.expectedMinMutations ?? 0),
+            });
+        };
+        if (!root) {
+            finish(false);
+            return;
+        }
+        const armQuietTimer = () => {
+            if (quietTimer !== undefined)
+                window.clearTimeout(quietTimer);
+            quietTimer = window.setTimeout(() => finish(true), quietMs);
+        };
+        observer = new MutationObserver((records) => {
+            mutationCount += records.length;
+            armQuietTimer();
+        });
+        observer.observe(root, { attributes: true, childList: true, subtree: true });
+        timeoutTimer = window.setTimeout(() => finish(false), timeoutMs);
+        armQuietTimer();
+    }), options);
+}
+export async function runFormstackIframePrefillSmoke(page, options) {
+    const bridge = await sendFormstackIframePrefillMessage(page, options);
+    const responseData = bridge.response.record?.data;
+    const responseOk = Boolean(responseData && typeof responseData === "object" && Reflect.get(responseData, "ok") === true);
+    const ok = bridge.posted && bridge.response.matched && (options.expectResponseOk === false || responseOk);
+    return { bridge, ok };
+}
+export async function runFormstackIframePrefillScenario(page, options) {
+    const prefill = await runFormstackIframePrefillSmoke(page, options);
+    const layoutOptions = options.layout === true ? { iframeSelector: options.iframeSelector } : options.layout || undefined;
+    const layout = layoutOptions ? await diagnoseLiveFormIframeLayout(page, layoutOptions) : undefined;
+    return {
+        prefill,
+        ...(layout ? { layout } : {}),
+        ok: prefill.ok && (layout?.ok ?? true),
+    };
+}
 export async function assertLiveFormConditionalLogic(page, options) {
     const transaction = await performLiveFormFieldTransaction(page, {
         ...(options.trigger.transaction ?? {}),