@sudobility/testomniac_runner_service 0.1.36 → 0.1.38

package/dist/orchestrator/decomposition.js

@@ -1,7 +1,423 @@
 import { extractActionableItems } from "../extractors";
-import { detectScaffoldRegions } from "../scanner/component-detector";
+import { computeDecomposedHashes } from "../browser/page-utils";
+import { detectScaffoldRegions, } from "../scanner/component-detector";
+import { getBody, getContentBody, getFixedBody, } from "../scanner/html-decomposer";
+import { detectPatternsWithInstances } from "../scanner/pattern-detector";
+import { toRelativePath } from "../crawler/url-normalizer";
 import { PlaywrightAction, ExpectationType, ExpectationSeverity, } from "../domain/types";
 const LOG = (...args) => console.warn("[decomposition]", ...args);
+const MAX_PAGE_INTERACTION_CASES = 24;
+const MAX_REVERSIBLE_CHAINS = 4;
+const MAX_TAB_CHAINS_PER_GROUP = 2;
+function getStateTransitionPriority(item) {
+    const role = (item.role || "").toLowerCase();
+    const tagName = (item.tagName || "").toLowerCase();
+    const text = `${item.accessibleName || ""} ${item.textContent || ""}`.toLowerCase();
+    const attributes = item.attributes || {};
+    if (role === "tab" || attributes["aria-selected"] != null) {
+        return 100;
+    }
+    if (attributes["aria-expanded"] != null ||
+        attributes["aria-controls"] != null) {
+        return 95;
+    }
+    if (attributes["aria-haspopup"] === "menu" ||
+        text.includes("menu") ||
+        role === "menuitem") {
+        return 90;
+    }
+    if (tagName === "summary" ||
+        text.includes("accordion") ||
+        text.includes("expand") ||
+        text.includes("collapse")) {
+        return 85;
+    }
+    if (text.includes("open") ||
+        text.includes("details") ||
+        text.includes("show") ||
+        text.includes("more")) {
+        return 80;
+    }
+    return 0;
+}
+function prioritizeItemsForExploration(items) {
+    return [...items].sort((left, right) => {
+        const delta = getStateTransitionPriority(right) - getStateTransitionPriority(left);
+        if (delta !== 0) {
+            return delta;
+        }
+        return (left.selector || "").localeCompare(right.selector || "");
+    });
+}
+function escapeSelector(selector) {
+    return selector.replace(/'/g, "\\'");
+}
+function buildExpectation() {
+    return {
+        expectationType: ExpectationType.NoConsoleErrors,
+        severity: ExpectationSeverity.ShouldPass,
+        description: "No console errors after interaction",
+        playwrightCode: "expect(consoleErrors).toHaveLength(0);",
+    };
+}
+function buildClickStep(item, pageStateId, description) {
+    return {
+        action: {
+            actionType: PlaywrightAction.Click,
+            pageStateId,
+            path: item.selector,
+            playwrightCode: `await page.click('${escapeSelector(item.selector)}');`,
+            description,
+        },
+        expectations: [buildExpectation()],
+        description,
+        continueOnFailure: false,
+    };
+}
+function isTabLike(item) {
+    const role = (item.role || "").toLowerCase();
+    const attributes = item.attributes || {};
+    return role === "tab" || attributes["aria-selected"] != null;
+}
+function isSelfReversibleStateControl(item) {
+    const tagName = (item.tagName || "").toLowerCase();
+    const text = `${item.accessibleName || ""} ${item.textContent || ""}`.toLowerCase();
+    const attributes = item.attributes || {};
+    return (attributes["aria-expanded"] != null ||
+        attributes["aria-haspopup"] === "menu" ||
+        attributes["aria-controls"] != null ||
+        tagName === "summary" ||
+        text.includes("open") ||
+        text.includes("close") ||
+        text.includes("details") ||
+        text.includes("show") ||
+        text.includes("more"));
+}
+function isExplicitCloseControl(item) {
+    const text = `${item.accessibleName || ""} ${item.textContent || ""}`.toLowerCase();
+    return (text.includes("close") ||
+        text.includes("dismiss") ||
+        text.includes("cancel") ||
+        text.includes("hide") ||
+        text.includes("done"));
+}
+async function resolveCloseControl(adapter, item, items) {
+    const controlledId = typeof item.attributes?.["aria-controls"] === "string"
+        ? String(item.attributes["aria-controls"])
+        : null;
+    const closeCandidates = items.filter(candidate => candidate.selector &&
+        candidate.selector !== item.selector &&
+        candidate.visible &&
+        !candidate.disabled &&
+        isExplicitCloseControl(candidate));
+    if (closeCandidates.length === 0 || !controlledId) {
+        return null;
+    }
+    const selectors = closeCandidates.map(candidate => candidate.selector);
+    const matchingSelector = await adapter.evaluate((...args) => {
+        const triggerSelector = args[0];
+        const targetId = args[1];
+        const candidateSelectors = args[2];
+        try {
+            const trigger = document.querySelector(triggerSelector);
+            const controlled = document.getElementById(targetId) ||
+                document.querySelector(`[aria-labelledby="${targetId}"], [data-panel="${targetId}"]`);
+            if (!trigger || !controlled)
+                return null;
+            for (const selector of candidateSelectors) {
+                const candidate = document.querySelector(selector);
+                if (candidate &&
+                    (controlled.contains(candidate) ||
+                        candidate.closest(`[id="${targetId}"]`))) {
+                    return selector;
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }, item.selector, controlledId, selectors);
+    if (!matchingSelector) {
+        return null;
+    }
+    return (closeCandidates.find(candidate => candidate.selector === matchingSelector) ?? null);
+}
+async function buildStateTransitionDefinitions(adapter, items, pageStateId) {
+    const definitions = [];
+    const seenTitles = new Set();
+    const reversibleItems = items
+        .filter(item => isSelfReversibleStateControl(item) && !isExplicitCloseControl(item))
+        .slice(0, MAX_REVERSIBLE_CHAINS);
+    for (const item of reversibleItems) {
+        const label = item.accessibleName ||
+            item.textContent ||
+            item.tagName ||
+            item.selector?.slice(0, 30) ||
+            "element";
+        const title = `state chain: ${label}`;
+        if (seenTitles.has(title))
+            continue;
+        seenTitles.add(title);
+        const explicitCloseControl = await resolveCloseControl(adapter, item, items);
+        definitions.push({
+            title,
+            actionType: "state_chain",
+            item,
+            steps: [
+                buildClickStep(item, pageStateId, `open ${label}`),
+                buildClickStep(explicitCloseControl ?? item, pageStateId, `close ${label}`),
+            ],
+        });
+    }
+    const tabItems = items.filter(isTabLike);
+    const tabGroups = await resolveTabGroups(adapter, tabItems);
+    for (const group of tabGroups) {
+        for (let index = 0; index < Math.min(group.length - 1, MAX_TAB_CHAINS_PER_GROUP); index += 1) {
+            const first = group[index];
+            const second = group[index + 1];
+            const firstLabel = first.accessibleName || first.textContent || first.selector || "tab";
+            const secondLabel = second.accessibleName || second.textContent || second.selector || "tab";
+            const title = `tab chain: ${firstLabel} -> ${secondLabel}`;
+            if (seenTitles.has(title))
+                continue;
+            seenTitles.add(title);
+            definitions.push({
+                title,
+                actionType: "tab_chain",
+                item: first,
+                steps: [
+                    buildClickStep(first, pageStateId, `activate ${firstLabel}`),
+                    buildClickStep(second, pageStateId, `activate ${secondLabel}`),
+                ],
+            });
+        }
+    }
+    return definitions;
+}
+async function resolveTabGroups(adapter, items) {
+    if (items.length < 2) {
+        return items.length > 0 ? [items] : [];
+    }
+    const metadata = await adapter.evaluate((...args) => {
+        const selectors = args[0];
+        return selectors.map((selector, index) => {
+            try {
+                const el = document.querySelector(selector);
+                if (!el) {
+                    return { selector, groupKey: "__missing__", order: index };
+                }
+                const container = el.closest('[role="tablist"]') ||
+                    el.closest("[data-tabs]") ||
+                    el.closest(".tabs") ||
+                    el.closest('[role="toolbar"]') ||
+                    el.parentElement;
+                const groupKey = container?.getAttribute("id") ||
+                    container?.getAttribute("aria-label") ||
+                    container?.getAttribute("data-tabs") ||
+                    container?.tagName ||
+                    "__ungrouped__";
+                const siblings = container
+                    ? Array.from(container.querySelectorAll('[role="tab"], [aria-selected], button, a'))
+                    : [];
+                const order = siblings.findIndex(candidate => candidate === el);
+                return {
+                    selector,
+                    groupKey,
+                    order: order >= 0 ? order : index,
+                };
+            }
+            catch {
+                return { selector, groupKey: "__error__", order: index };
+            }
+        });
+    }, items.map(item => item.selector));
+    const itemBySelector = new Map(items.map(item => [item.selector, item]));
+    const groups = new Map();
+    for (const entry of metadata) {
+        const item = itemBySelector.get(entry.selector);
+        if (!item)
+            continue;
+        const bucket = groups.get(entry.groupKey) ?? [];
+        bucket.push({ item, order: entry.order });
+        groups.set(entry.groupKey, bucket);
+    }
+    return Array.from(groups.values())
+        .map(group => group
+        .sort((left, right) => left.order - right.order)
+        .map(entry => entry.item))
+        .filter(group => group.length >= 2);
+}
+function dedupeDefinitions(definitions) {
+    const seen = new Set();
+    const deduped = [];
+    for (const definition of definitions) {
+        if (seen.has(definition.title))
+            continue;
+        seen.add(definition.title);
+        deduped.push(definition);
+    }
+    return deduped;
+}
+function inferFillValue(item) {
+    const inputType = (item.inputType || "").toLowerCase();
+    const label = `${item.accessibleName || ""} ${item.textContent || ""}`.toLowerCase();
+    if (inputType === "email" || label.includes("email")) {
+        return "testomniac@example.com";
+    }
+    if (inputType === "tel" || label.includes("phone")) {
+        return "4155550100";
+    }
+    if (inputType === "number") {
+        return "1";
+    }
+    if (inputType === "search" || label.includes("search")) {
+        return "test";
+    }
+    if (inputType === "url" ||
+        label.includes("url") ||
+        label.includes("website")) {
+        return "https://example.com";
+    }
+    if (inputType === "password") {
+        return "Testomniac123!";
+    }
+    return "Testomniac";
+}
+async function resolveSelectValue(adapter, selector) {
+    return adapter.evaluate((...args) => {
+        const targetSelector = args[0];
+        try {
+            const select = document.querySelector(targetSelector);
+            if (!(select instanceof HTMLSelectElement)) {
+                return null;
+            }
+            const options = Array.from(select.options).filter(option => !option.disabled);
+            const preferred = options.find(option => option.value && option.value !== select.value) ||
+                options.find(option => option.value) ||
+                options.find(option => option.textContent?.trim());
+            return preferred?.value || null;
+        }
+        catch {
+            return null;
+        }
+    }, selector);
+}
+async function buildGeneratedTestCase(adapter, item, pageStateId) {
+    const actionKind = item.actionKind || "click";
+    const label = item.accessibleName ||
+        item.tagName ||
+        item.selector?.slice(0, 30) ||
+        "element";
+    let actionType;
+    let playwrightAction;
+    let playwrightCode;
+    let value;
+    if (actionKind === "navigate" || actionKind === "click") {
+        actionType = "click";
+        playwrightAction = PlaywrightAction.Click;
+        playwrightCode = `await page.click('${escapeSelector(item.selector)}');`;
+    }
+    else if (actionKind === "fill") {
+        actionType = "fill";
+        playwrightAction = PlaywrightAction.Fill;
+        value = inferFillValue(item);
+        playwrightCode = `await page.fill('${escapeSelector(item.selector)}', '${value.replace(/'/g, "\\'")}');`;
+    }
+    else if (actionKind === "select") {
+        actionType = "select";
+        playwrightAction = PlaywrightAction.SelectOption;
+        value = (await resolveSelectValue(adapter, item.selector)) ?? undefined;
+        if (!value) {
+            return null;
+        }
+        playwrightCode = `await page.selectOption('${escapeSelector(item.selector)}', '${value.replace(/'/g, "\\'")}');`;
+    }
+    else if (actionKind === "radio_select") {
+        actionType = "radio_select";
+        playwrightAction = PlaywrightAction.Click;
+        playwrightCode = `await page.click('${escapeSelector(item.selector)}');`;
+    }
+    else {
+        actionType = "click";
+        playwrightAction = PlaywrightAction.Click;
+        playwrightCode = `await page.click('${escapeSelector(item.selector)}');`;
+    }
+    const steps = [
+        {
+            action: {
+                actionType: playwrightAction,
+                pageStateId,
+                path: item.selector,
+                value,
+                playwrightCode,
+                description: `${actionType} on ${label}`,
+            },
+            expectations: [buildExpectation()],
+            description: `${actionType} on ${label}`,
+            continueOnFailure: false,
+        },
+    ];
+    return {
+        title: `${actionType}: ${label}`,
+        actionType,
+        item,
+        steps,
+    };
+}
+async function classifyItemsByScaffold(adapter, items, scaffolds) {
+    if (items.length === 0 || scaffolds.length === 0) {
+        return { pageItems: items, scaffoldItems: new Map() };
+    }
+    const assignments = await adapter.evaluate((...args) => {
+        const selectors = args[0];
+        const scaffoldSelectors = args[1];
+        return selectors.map(selector => {
+            try {
+                const el = document.querySelector(selector);
+                if (!el)
+                    return null;
+                for (const scaffold of scaffoldSelectors) {
+                    try {
+                        const scaffoldEl = document.querySelector(scaffold.selector);
+                        if (scaffoldEl &&
+                            (el === scaffoldEl || scaffoldEl.contains(el))) {
+                            return scaffold.scaffoldId;
+                        }
+                    }
+                    catch {
+                        // Ignore invalid scaffold selector.
+                    }
+                }
+            }
+            catch {
+                // Ignore invalid item selector.
+            }
+            return null;
+        });
+    }, items.map(item => item.selector), scaffolds.map(scaffold => ({
+        scaffoldId: scaffold.scaffoldId,
+        selector: scaffold.selector,
+    })));
+    const scaffoldItems = new Map();
+    const pageItems = [];
+    for (const [index, item] of items.entries()) {
+        const scaffoldId = assignments[index];
+        if (typeof scaffoldId === "number") {
+            const existing = scaffoldItems.get(scaffoldId) ?? [];
+            existing.push(item);
+            scaffoldItems.set(scaffoldId, existing);
+        }
+        else {
+            pageItems.push(item);
+        }
+    }
+    return { pageItems, scaffoldItems };
+}
+function findExistingSuiteId(suites, scaffoldId) {
+    const suite = suites.find(item => item.scaffoldId === scaffoldId);
+    return suite?.id ?? null;
+}
 /**
  * Process a decomposition job: extract actionable items from the live page
  * and generate click/hover test cases. Returns created test case IDs.
@@ -18,7 +434,14 @@ export async function processDecompositionJob(job, adapter, config, api, events)
         throw new Error(`Page ${pageState.pageId} not found`);
     }
     LOG(`Page found: relativePath=${page.relativePath}`);
+    const targetUrl = new URL(page.relativePath, config.baseUrl).toString();
+    const currentUrl = await adapter.getUrl();
+    if (toRelativePath(currentUrl) !== toRelativePath(targetUrl)) {
+        LOG(`Navigating to ${targetUrl} for decomposition job ${job.id}`);
+        await adapter.goto(targetUrl, { waitUntil: "networkidle0" });
+    }
     // Extract actionable items from the live page
+    const currentHtml = await adapter.content();
     const items = await extractActionableItems(adapter);
     LOG(`Extracted ${items.length} actionable items:`, items.map(i => ({
         selector: i.selector?.slice(0, 60),
@@ -33,6 +456,7 @@ export async function processDecompositionJob(job, adapter, config, api, events)
     const scaffolds = await detectScaffoldRegions(adapter);
     LOG(`Detected ${scaffolds.length} scaffolds:`, scaffolds.map(s => ({ type: s.type, selector: s.selector })));
     // Persist scaffolds and link to page state
+    const persistedScaffolds = [];
     if (scaffolds.length > 0) {
         const scaffoldIds = [];
         for (const scaffold of scaffolds) {
@@ -44,6 +468,7 @@ export async function processDecompositionJob(job, adapter, config, api, events)
                     html: scaffold.outerHtml,
                 });
                 scaffoldIds.push(saved.id);
+                persistedScaffolds.push({ ...scaffold, scaffoldId: saved.id });
                 LOG(`Scaffold saved: type=${scaffold.type} id=${saved.id}`);
             }
             catch (err) {
@@ -60,6 +485,23 @@ export async function processDecompositionJob(job, adapter, config, api, events)
             }
         }
     }
+    const patterns = await detectPatternsWithInstances(adapter);
+    const bodyHtml = getBody(currentHtml);
+    const { contentBody } = getContentBody(bodyHtml, scaffolds);
+    const patternInstances = patterns.flatMap(pattern => pattern.instances);
+    const { fixedBody } = getFixedBody(contentBody, patternInstances);
+    const decomposedHashes = await computeDecomposedHashes(fixedBody, scaffolds, patterns);
+    const existingDecomposedState = await api.findMatchingPageStateDecomposed(page.id, decomposedHashes, config.sizeClass);
+    await api.updatePageStateDecomposedHashes(pageState.id, decomposedHashes);
+    await api.insertPageStatePatterns(pageState.id, patterns.map(pattern => ({
+        type: pattern.type,
+        selector: pattern.selector,
+        count: pattern.count,
+    })));
+    if (existingDecomposedState && existingDecomposedState.id !== pageState.id) {
+        LOG(`Skipping decomposition for pageState ${pageState.id}; matched existing decomposed state ${existingDecomposedState.id}`);
+        return [];
+    }
     // Filter to visible, enabled, interactive items
     const interactiveItems = items.filter(i => i.visible && !i.disabled && i.selector);
     LOG(`${interactiveItems.length} items after filtering (visible, enabled, has selector)`);
@@ -67,84 +509,62 @@ export async function processDecompositionJob(job, adapter, config, api, events)
         LOG("No interactive items found — skipping decomposition");
         return [];
     }
-    // Create a test suite for this decomposition job
-    const suite = await api.insertTestSuite(config.runnerId, {
-        title: `Page State #${job.pageStateId}`,
-        description: `Auto-generated test suite for page state ${job.pageStateId} on ${page.relativePath}`,
-        startingPageStateId: job.pageStateId,
-        startingPath: page.relativePath,
-        sizeClass: config.sizeClass,
-        priority: 3,
-        suite_tags: ["auto-generated"],
-        decompositionJobId: job.id,
-    });
-    LOG(`Created test suite: id=${suite.id}, title=${suite.title}`);
-    events.onTestSuiteCreated({ suiteId: suite.id, title: suite.title });
+    const { pageItems, scaffoldItems } = await classifyItemsByScaffold(adapter, interactiveItems, persistedScaffolds);
+    LOG(`Classified ${pageItems.length} page items and ${Array.from(scaffoldItems.values()).reduce((count, value) => count + value.length, 0)} scaffold items`);
+    const existingSuites = await api.getTestSuitesByRunner(config.runnerId);
+    const existingCases = await api.getTestCasesByRunner(config.runnerId);
+    let pageSuiteId = null;
     // Generate one test case per actionable item (cap at 20 to avoid explosion)
-    const maxItems = Math.min(interactiveItems.length, 20);
     const createdIds = [];
-    for (let i = 0; i < maxItems; i++) {
-        const item = interactiveItems[i];
-        const actionKind = item.actionKind || "click";
-        const label = item.accessibleName ||
-            item.tagName ||
-            item.selector?.slice(0, 30) ||
-            "element";
-        // Determine test action type
-        let actionType;
-        if (actionKind === "navigate" || actionKind === "click") {
-            actionType = "click";
-        }
-        else if (actionKind === "fill") {
-            actionType = "fill";
-        }
-        else if (actionKind === "select") {
-            actionType = "select";
-        }
-        else {
-            actionType = "click";
-        }
-        const steps = [
-            {
-                action: {
-                    actionType: PlaywrightAction.Click,
-                    pageStateId: pageState.id,
-                    path: item.selector,
-                    playwrightCode: `await page.click('${item.selector.replace(/'/g, "\\'")}');`,
-                    description: `${actionType} on ${label}`,
-                },
-                expectations: [
-                    {
-                        expectationType: ExpectationType.NoConsoleErrors,
-                        severity: ExpectationSeverity.ShouldPass,
-                        description: "No console errors after interaction",
-                        playwrightCode: "expect(consoleErrors).toHaveLength(0);",
-                    },
-                ],
-                description: `${actionType} on ${label}`,
-                continueOnFailure: false,
-            },
-        ];
+    const prioritizedPageItems = prioritizeItemsForExploration(pageItems);
+    const pageChainDefinitions = await buildStateTransitionDefinitions(adapter, prioritizedPageItems, pageState.id);
+    const pageSingleDefinitions = (await Promise.all(prioritizedPageItems
+        .slice(0, MAX_PAGE_INTERACTION_CASES)
+        .map(item => buildGeneratedTestCase(adapter, item, pageState.id)))).filter((definition) => Boolean(definition));
+    const pageDefinitions = dedupeDefinitions([
+        ...pageChainDefinitions,
+        ...pageSingleDefinitions,
+    ]).slice(0, MAX_PAGE_INTERACTION_CASES);
+    if (pageDefinitions.length > 0) {
+        const pageSuite = await api.insertTestSuite(config.runnerId, {
+            title: `Page State #${job.pageStateId}`,
+            description: `Auto-generated test suite for page state ${job.pageStateId} on ${page.relativePath}`,
+            startingPageStateId: job.pageStateId,
+            startingPath: page.relativePath,
+            sizeClass: config.sizeClass,
+            priority: 3,
+            suite_tags: ["auto-generated", "page-interactions"],
+            decompositionJobId: job.id,
+        });
+        pageSuiteId = pageSuite.id;
+        LOG(`Created test suite: id=${pageSuite.id}, title=${pageSuite.title}`);
+        events.onTestSuiteCreated({
+            suiteId: pageSuite.id,
+            title: pageSuite.title,
+        });
+    }
+    for (const [index, definition] of pageDefinitions.entries()) {
+        if (!pageSuiteId)
+            break;
         const testCase = {
-            title: `${actionType}: ${label}`,
+            title: definition.title,
             type: "interaction",
             sizeClass: config.sizeClass,
-            suite_tags: ["auto-generated", "mouse-scanning"],
+            suite_tags: ["auto-generated", "mouse-scanning", "page-interactions"],
             page_id: page.id,
             priority: 3,
             startingPageStateId: pageState.id,
             startingPath: page.relativePath,
-            steps,
+            steps: definition.steps,
             globalExpectations: [],
         };
-        LOG(`Creating test case ${i + 1}/${maxItems}: "${testCase.title}" selector=${item.selector?.slice(0, 60)}`);
-        const tc = await api.insertTestCase(config.runnerId, testCase);
+        LOG(`Creating page test case ${index + 1}/${pageDefinitions.length}: "${testCase.title}" selector=${definition.item.selector?.slice(0, 60)}`);
+        const tc = await api.insertTestCase(config.runnerId, testCase, pageSuiteId);
         createdIds.push(tc.id);
-        // Create test actions for each step
-        for (const [index, step] of steps.entries()) {
+        for (const [stepIndex, step] of definition.steps.entries()) {
             await api.createTestAction({
                 testCaseId: tc.id,
-                stepOrder: index,
+                stepOrder: stepIndex,
                 actionType: step.action.actionType,
                 pageStateId: step.action.pageStateId,
                 elementIdentityId: step.action.elementIdentityId,
@@ -159,6 +579,79 @@ export async function processDecompositionJob(job, adapter, config, api, events)
             });
         }
     }
+    for (const scaffold of persistedScaffolds) {
+        const itemsForScaffold = scaffoldItems.get(scaffold.scaffoldId) ?? [];
+        if (itemsForScaffold.length === 0) {
+            continue;
+        }
+        let scaffoldSuiteId = findExistingSuiteId(existingSuites, scaffold.scaffoldId);
+        if (!scaffoldSuiteId) {
+            const suite = await api.insertTestSuite(config.runnerId, {
+                title: `Shared Scaffold: ${scaffold.type}`,
+                description: `Auto-generated shared scaffold suite for ${scaffold.type}`,
+                startingPageStateId: job.pageStateId,
+                startingPath: page.relativePath,
+                sizeClass: config.sizeClass,
+                scaffoldId: scaffold.scaffoldId,
+                scaffoldType: scaffold.type,
+                priority: 2,
+                suite_tags: ["auto-generated", "shared-scaffold"],
+            });
+            scaffoldSuiteId = suite.id;
+            existingSuites.push(suite);
+            LOG(`Created scaffold suite ${suite.id} for scaffold ${scaffold.scaffoldId}`);
+            events.onTestSuiteCreated({ suiteId: suite.id, title: suite.title });
+        }
+        const prioritizedScaffoldItems = prioritizeItemsForExploration(itemsForScaffold);
+        const scaffoldChainDefinitions = await buildStateTransitionDefinitions(adapter, prioritizedScaffoldItems, pageState.id);
+        const scaffoldSingleDefinitions = (await Promise.all(prioritizedScaffoldItems
+            .slice(0, MAX_PAGE_INTERACTION_CASES)
+            .map(item => buildGeneratedTestCase(adapter, item, pageState.id)))).filter((definition) => Boolean(definition));
+        const scaffoldDefinitions = dedupeDefinitions([
+            ...scaffoldChainDefinitions,
+            ...scaffoldSingleDefinitions,
+        ]).slice(0, MAX_PAGE_INTERACTION_CASES);
+        for (const definition of scaffoldDefinitions) {
+            const duplicate = existingCases.find(testCase => testCase.scaffoldId === scaffold.scaffoldId &&
+                testCase.title === definition.title);
+            if (duplicate) {
+                continue;
+            }
+            const testCase = {
+                title: definition.title,
+                type: "interaction",
+                sizeClass: config.sizeClass,
+                suite_tags: ["auto-generated", "mouse-scanning", "shared-scaffold"],
+                page_id: page.id,
+                scaffoldId: scaffold.scaffoldId,
+                priority: 2,
+                startingPageStateId: pageState.id,
+                startingPath: page.relativePath,
+                steps: definition.steps,
+                globalExpectations: [],
+            };
+            const tc = await api.insertTestCase(config.runnerId, testCase, scaffoldSuiteId);
+            existingCases.push(tc);
+            createdIds.push(tc.id);
+            for (const [stepIndex, step] of definition.steps.entries()) {
+                await api.createTestAction({
+                    testCaseId: tc.id,
+                    stepOrder: stepIndex,
+                    actionType: step.action.actionType,
+                    pageStateId: step.action.pageStateId,
+                    elementIdentityId: step.action.elementIdentityId,
+                    containerType: step.action.containerType,
+                    containerElementIdentityId: step.action.containerElementIdentityId,
+                    value: step.action.value,
+                    path: step.action.path,
+                    playwrightCode: step.action.playwrightCode,
+                    description: step.description,
+                    expectations: step.expectations,
+                    continueOnFailure: step.continueOnFailure,
+                });
+            }
+        }
+    }
     LOG(`Decomposition complete: created ${createdIds.length} test cases`);
     return createdIds;
 }