@intuned/browser-dev 0.1.5-dev.0 → 0.1.5-dev.1

package/dist/helpers/frame_utils/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IFRAME_TAGS = exports.ALL_IFRAMES_CSS_SELECTOR = void 0;
+const IFRAME_TAGS = exports.IFRAME_TAGS = ["iframe", "frame"];
+const ALL_IFRAMES_CSS_SELECTOR = exports.ALL_IFRAMES_CSS_SELECTOR = IFRAME_TAGS.join(", ");

package/dist/helpers/frame_utils/findAllIframes.js

@@ -0,0 +1,79 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findAllIframes = findAllIframes;
+exports.findAllIframesList = findAllIframesList;
+var _Logger = require("../../common/Logger");
+var _constants = require("./constants");
+async function findAllIframes(root, iframeTimeoutMs = 10000) {
+  const processed = new Set();
+  return await processFrameRecursive(root, processed, iframeTimeoutMs);
+}
+async function findAllIframesList(root, iframeTimeoutMs = 10000) {
+  const iframeNodes = await findAllIframes(root, iframeTimeoutMs);
+  return flattenIframeTree(iframeNodes);
+}
+async function processFrameRecursive(root, processedRoots, iframeTimeoutMs) {
+  if (processedRoots.has(root)) {
+    return [];
+  }
+  processedRoots.add(root);
+  const iframeNodes = [];
+  try {
+    const iframeLocator = root.locator(_constants.ALL_IFRAMES_CSS_SELECTOR);
+    let iframeCount;
+    try {
+      iframeCount = await Promise.race([iframeLocator.count(), new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), iframeTimeoutMs))]);
+    } catch (error) {
+      _Logger.logger.error("Timeout counting iframes in context, skipping");
+      return [];
+    }
+    for (let i = 0; i < iframeCount; i++) {
+      try {
+        const processSingleIframe = async index => {
+          const iframeElementLocator = iframeLocator.nth(index);
+          const iframeElement = await iframeElementLocator.elementHandle();
+          if (!iframeElement) {
+            _Logger.logger.error(`Could not get element handle for iframe: ${iframeElement}`);
+            return null;
+          }
+          const contentFrame = await iframeElement.contentFrame();
+          if (!contentFrame) {
+            _Logger.logger.error(`Could not access content_frame for iframe: ${iframeElement}`);
+            return null;
+          }
+          const nestedIframes = await processFrameRecursive(contentFrame, processedRoots, iframeTimeoutMs);
+          return {
+            frame: contentFrame,
+            nestedIframes: nestedIframes
+          };
+        };
+        const iframeNode = await Promise.race([processSingleIframe(i), new Promise((_, reject) => setTimeout(() => reject(new Error("Timeout")), iframeTimeoutMs))]);
+        if (iframeNode !== null) {
+          iframeNodes.push(iframeNode);
+        }
+      } catch (error) {
+        _Logger.logger.error(`Timeout processing iframe ${i} in context, skipping`);
+        continue;
+      }
+    }
+  } catch (error) {
+    _Logger.logger.error(`Error processing frames in context: ${error}`);
+  }
+  return iframeNodes;
+}
+function flattenIframeTree(iframeNodes) {
+  const flattened = [];
+  function flattenRecursive(nodes) {
+    for (const node of nodes) {
+      flattened.push(node);
+      if (node.nestedIframes && node.nestedIframes.length > 0) {
+        flattenRecursive(node.nestedIframes);
+      }
+    }
+  }
+  flattenRecursive(iframeNodes);
+  return flattened;
+}

package/dist/helpers/frame_utils/getContainerFrame.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getContainerFrame = getContainerFrame;
+async function getContainerFrame(element) {
+  let handle;
+  if ("elementHandle" in element) {
+    handle = await element.elementHandle();
+  } else {
+    handle = element;
+  }
+  if (!handle) {
+    throw new Error("Could not get element handle");
+  }
+  const frame = await handle.ownerFrame();
+  if (!frame) {
+    throw new Error("Could not get owner frame for element");
+  }
+  return frame;
+}

package/dist/helpers/frame_utils/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ALL_IFRAMES_CSS_SELECTOR", {
+  enumerable: true,
+  get: function () {
+    return _constants.ALL_IFRAMES_CSS_SELECTOR;
+  }
+});
+Object.defineProperty(exports, "IFRAME_TAGS", {
+  enumerable: true,
+  get: function () {
+    return _constants.IFRAME_TAGS;
+  }
+});
+Object.defineProperty(exports, "IframeNode", {
+  enumerable: true,
+  get: function () {
+    return _findAllIframes.IframeNode;
+  }
+});
+Object.defineProperty(exports, "findAllIframes", {
+  enumerable: true,
+  get: function () {
+    return _findAllIframes.findAllIframes;
+  }
+});
+Object.defineProperty(exports, "findAllIframesList", {
+  enumerable: true,
+  get: function () {
+    return _findAllIframes.findAllIframesList;
+  }
+});
+Object.defineProperty(exports, "getContainerFrame", {
+  enumerable: true,
+  get: function () {
+    return _getContainerFrame.getContainerFrame;
+  }
+});
+var _findAllIframes = require("./findAllIframes");
+var _getContainerFrame = require("./getContainerFrame");
+var _constants = require("./constants");

package/dist/helpers/frame_utils/tests/testFindAllIframes.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+
+var _extendedTest = require("../../../common/extendedTest");
+var _playwrightCore = require("playwright-core");
+var _findAllIframes = require("../findAllIframes");
+(0, _extendedTest.describe)("Test findAllIframes", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwrightCore.chromium.launch({
+      headless: true
+    });
+  });
+  (0, _extendedTest.afterAll)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.beforeEach)(async () => {
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await page.close();
+  });
+  (0, _extendedTest.test)("should find all iframes - basic", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <iframe id="iframe-1"
+                  src="data:text/html,<html><body><h2>Iframe 1</h2></body></html>"
+                  width="300"
+                  height="200">
+          </iframe>
+          <iframe id="iframe-2"
+                  src="data:text/html,<html><body><h2>Iframe 2</h2></body></html>"
+                  width="300"
+                  height="200">
+          </iframe>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page);
+    (0, _extendedTest.expect)(iframeNodes.length).toBe(2);
+    (0, _extendedTest.expect)(iframeNodes[0].frame).toBeDefined();
+    (0, _extendedTest.expect)(iframeNodes[1].frame).toBeDefined();
+    (0, _extendedTest.expect)(iframeNodes[0].nestedIframes.length).toBe(0);
+    (0, _extendedTest.expect)(iframeNodes[1].nestedIframes.length).toBe(0);
+  });
+  (0, _extendedTest.test)("should find nested iframes", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <iframe id="outer-iframe"
+                  src="data:text/html,<html><body><h2>Outer</h2><iframe src='data:text/html,<html><body><h3>Inner</h3></body></html>'></iframe></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page);
+    (0, _extendedTest.expect)(iframeNodes.length).toBe(1);
+    (0, _extendedTest.expect)(iframeNodes[0].nestedIframes.length).toBe(1);
+    (0, _extendedTest.expect)(iframeNodes[0].nestedIframes[0].nestedIframes.length).toBe(0);
+  });
+  (0, _extendedTest.test)("should handle page with no iframes", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <p>No iframes here</p>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page);
+    (0, _extendedTest.expect)(iframeNodes.length).toBe(0);
+  });
+  (0, _extendedTest.test)("should handle problematic iframe sources", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <iframe id="javascript-iframe"
+                  src="javascript:"
+                  width="300"
+                  height="200">
+          </iframe>
+          <iframe id="blob-iframe"
+                  src="blob:null/invalid"
+                  width="300"
+                  height="200">
+          </iframe>
+          <iframe id="about-blank-iframe"
+                  src="about:blank"
+                  width="300"
+                  height="200">
+          </iframe>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded",
+      timeout: 5000
+    });
+    const startTime = Date.now();
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page, 2000);
+    const elapsedTime = Date.now() - startTime;
+    (0, _extendedTest.expect)(elapsedTime).toBeLessThan(10000);
+    (0, _extendedTest.expect)(iframeNodes.length).toBeLessThan(3);
+  });
+  (0, _extendedTest.test)("should find iframes with srcdoc attribute", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <iframe id="srcdoc-iframe"
+                  srcdoc="<html><body><h2>Srcdoc Content</h2></body></html>"
+                  width="300"
+                  height="200">
+          </iframe>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page);
+    (0, _extendedTest.expect)(iframeNodes.length).toBe(1);
+  });
+  (0, _extendedTest.test)("should handle legacy frame elements", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <head><title>Legacy Frameset</title></head>
+        <frameset cols="50%,50%">
+          <frame id="frame-1"
+                 src="data:text/html,<html><body><h2>Frame 1</h2></body></html>">
+          </frame>
+          <frame id="frame-2"
+                 src="data:text/html,<html><body><h2>Frame 2</h2></body></html>">
+          </frame>
+        </frameset>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeNodes = await (0, _findAllIframes.findAllIframes)(page);
+    (0, _extendedTest.expect)(iframeNodes.length).toBeGreaterThanOrEqual(0);
+    for (const node of iframeNodes) {
+      (0, _extendedTest.expect)(node.frame).toBeDefined();
+    }
+  });
+  (0, _extendedTest.test)("findAllIframesList should return flat list", async () => {
+    await page.goto(`data:text/html,
+      <html>
+        <body>
+          <h1>Main Content</h1>
+          <iframe id="outer-iframe"
+                  src="data:text/html,<html><body><h2>Outer</h2><iframe id='inner-iframe' src='data:text/html,<html><body><h3>Inner</h3></body></html>'></iframe></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>`, {
+      waitUntil: "domcontentloaded"
+    });
+    const iframeList = await (0, _findAllIframes.findAllIframesList)(page);
+    (0, _extendedTest.expect)(iframeList.length).toBe(2);
+    for (const node of iframeList) {
+      (0, _extendedTest.expect)(node.frame).toBeDefined();
+    }
+  });
+});

package/dist/helpers/tests/testWithDomSettledWait.spec.js

@@ -161,4 +161,123 @@ var _waitForDomSettled = require("../waitForDomSettled");
     const content = await page.textContent("#target");
     (0, _extendedTest.expect)(content).toContain("Locator source content");
   });
+  (0, _extendedTest.test)("should wait for DOM to settle with iframe dynamic content", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <iframe id="test-iframe"
+                  src="data:text/html,<html><body><div id='iframe-content'>Initial content</div></body></html>"
+                  width="400"
+                  height="300">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(500);
+    const iframeElement = await page.locator("#test-iframe").elementHandle();
+    const iframeFrame = await (iframeElement === null || iframeElement === void 0 ? void 0 : iframeElement.contentFrame());
+    if (!iframeFrame) {
+      throw new Error("Could not get iframe frame");
+    }
+    await iframeFrame.evaluate(() => {
+      let counter = 0;
+      const intervalId = setInterval(() => {
+        counter++;
+        const div = document.createElement("div");
+        div.textContent = `Dynamic content ${counter}`;
+        div.className = "dynamic-item";
+        document.body.appendChild(div);
+        if (counter >= 3) {
+          clearInterval(intervalId);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const dynamicItems = await iframeFrame.locator(".dynamic-item").count();
+    (0, _extendedTest.expect)(dynamicItems).toBe(3);
+    for (let i = 0; i < 3; i++) {
+      const content = await iframeFrame.locator(".dynamic-item").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Dynamic content ${i + 1}`);
+    }
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle with nested iframes", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <h1>Main Page</h1>
+          <div id="main-content">Main content</div>
+          <iframe id="outer-iframe"
+                  src="data:text/html,<html><body><h2>Outer iframe</h2><div id='outer-content'>Outer initial</div><iframe id='inner-iframe' src='data:text/html,<html><body><h3>Inner iframe</h3><div id=inner-content>Inner initial</div></body></html>'></iframe></body></html>"
+                  width="500"
+                  height="400">
+          </iframe>
+        </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const outerIframeElement = await page.locator("#outer-iframe").elementHandle();
+    const outerFrame = await (outerIframeElement === null || outerIframeElement === void 0 ? void 0 : outerIframeElement.contentFrame());
+    if (!outerFrame) {
+      throw new Error("Could not get outer frame");
+    }
+    const innerIframeElement = await outerFrame.locator("#inner-iframe").elementHandle();
+    const innerFrame = await (innerIframeElement === null || innerIframeElement === void 0 ? void 0 : innerIframeElement.contentFrame());
+    if (!innerFrame) {
+      throw new Error("Could not get inner frame");
+    }
+    await outerFrame.evaluate(() => {
+      let outerCounter = 0;
+      const outerInterval = setInterval(() => {
+        outerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Outer dynamic ${outerCounter}`;
+        div.className = "outer-dynamic";
+        const outerContent = document.getElementById("outer-content");
+        outerContent === null || outerContent === void 0 || outerContent.appendChild(div);
+        if (outerCounter >= 2) {
+          clearInterval(outerInterval);
+        }
+      }, 150);
+    });
+    await innerFrame.evaluate(() => {
+      let innerCounter = 0;
+      const innerInterval = setInterval(() => {
+        innerCounter++;
+        const div = document.createElement("div");
+        div.textContent = `Inner dynamic ${innerCounter}`;
+        div.className = "inner-dynamic";
+        const innerContent = document.getElementById("inner-content");
+        innerContent === null || innerContent === void 0 || innerContent.appendChild(div);
+        if (innerCounter >= 2) {
+          clearInterval(innerInterval);
+        }
+      }, 200);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 1000,
+      timeoutInMs: 15000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const outerDynamicItems = await outerFrame.locator(".outer-dynamic").count();
+    (0, _extendedTest.expect)(outerDynamicItems).toBe(2);
+    const innerDynamicItems = await innerFrame.locator(".inner-dynamic").count();
+    (0, _extendedTest.expect)(innerDynamicItems).toBe(2);
+    for (let i = 0; i < 2; i++) {
+      const content = await outerFrame.locator(".outer-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Outer dynamic ${i + 1}`);
+    }
+    for (let i = 0; i < 2; i++) {
+      const content = await innerFrame.locator(".inner-dynamic").nth(i).textContent();
+      (0, _extendedTest.expect)(content).toBe(`Inner dynamic ${i + 1}`);
+    }
+  });
 });

package/dist/helpers/waitForDomSettled.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", {
 exports.waitForDomSettled = void 0;
 var _locatorHelpers = require("../common/locatorHelpers");
 var _Logger = require("../common/Logger");
+var _findAllIframes = require("./frame_utils/findAllIframes");
+var _getContainerFrame = require("./frame_utils/getContainerFrame");
 const waitForDomSettled = async options => {
   const {
     source,
@@ -14,10 +16,10 @@ const waitForDomSettled = async options => {
   } = options;
   const settleDurationMsFloored = Math.floor(settleDurationMs);
   const timeoutMs = Math.floor(timeoutInMs);
-  let pageObj;
+  let frame;
   let elementHandle;
   if (!(0, _locatorHelpers.isPage)(source)) {
-    pageObj = source.page();
+    frame = await (0, _getContainerFrame.getContainerFrame)(source);
     const handle = await source.elementHandle();
     if (!handle) {
       _Logger.logger.warn("Could not get element handle from locator");
@@ -25,46 +27,26 @@ const waitForDomSettled = async options => {
     }
     elementHandle = handle;
   } else if ((0, _locatorHelpers.isPage)(source)) {
-    pageObj = source;
-    elementHandle = await pageObj.evaluateHandle("document.documentElement");
+    frame = source.mainFrame();
+    elementHandle = await frame.evaluateHandle("document.documentElement");
   } else {
     throw new Error("Invalid state");
   }
-  try {
-    const result = await pageObj.evaluate(({
-      target,
+  const jsCode = (target, args) => {
+    const {
       settleDurationMsFloored,
       timeoutMs
-    }) => {
-      return new Promise((resolve, reject) => {
-        if (!target) {
-          reject(new Error("Target element not found"));
-          return;
-        }
-        let mutationTimer;
-        let settled = false;
-        const observer = new MutationObserver(() => {
-          if (settled) return;
-          clearTimeout(mutationTimer);
-          mutationTimer = window.setTimeout(() => {
-            settled = true;
-            observer.disconnect();
-            clearTimeout(timeoutTimer);
-            resolve(true);
-          }, settleDurationMsFloored);
-        });
-        const timeoutTimer = window.setTimeout(() => {
-          settled = true;
-          observer.disconnect();
-          clearTimeout(mutationTimer);
-          reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
-        }, timeoutMs);
-        observer.observe(target, {
-          childList: true,
-          subtree: true,
-          attributes: true,
-          characterData: true
-        });
+    } = args;
+    return new Promise((resolve, reject) => {
+      if (!target) {
+        reject(new Error("Target element not found"));
+        return;
+      }
+      let mutationTimer;
+      let settled = false;
+      const observer = new MutationObserver(() => {
+        if (settled) return;
+        clearTimeout(mutationTimer);
         mutationTimer = window.setTimeout(() => {
           settled = true;
           observer.disconnect();
@@ -72,12 +54,47 @@ const waitForDomSettled = async options => {
           resolve(true);
         }, settleDurationMsFloored);
       });
-    }, {
-      target: elementHandle,
+      const timeoutTimer = window.setTimeout(() => {
+        settled = true;
+        observer.disconnect();
+        clearTimeout(mutationTimer);
+        reject(new Error(`DOM timed out settling after ${timeoutMs} ms`));
+      }, timeoutMs);
+      observer.observe(target, {
+        childList: true,
+        subtree: true,
+        attributes: true,
+        characterData: true
+      });
+      mutationTimer = window.setTimeout(() => {
+        settled = true;
+        observer.disconnect();
+        clearTimeout(timeoutTimer);
+        resolve(true);
+      }, settleDurationMsFloored);
+    });
+  };
+  try {
+    const result = await elementHandle.evaluate(jsCode, {
       settleDurationMsFloored,
       timeoutMs
     });
-    return result;
+    if (!result) {
+      return false;
+    }
+    const allIframes = await (0, _findAllIframes.findAllIframesList)(frame);
+    for (const iframeNode of allIframes) {
+      const iframeElementHandle = await iframeNode.frame.evaluateHandle("document.documentElement");
+      const iframeResult = await iframeElementHandle.evaluate(jsCode, {
+        settleDurationMsFloored,
+        timeoutMs
+      });
+      await iframeElementHandle.dispose();
+      if (!iframeResult) {
+        return false;
+      }
+    }
+    return true;
   } catch (error) {
     _Logger.logger.warn(`DOM settlement detection failed: ${error}`);
     return false;

package/dist/optimized-extractors/listExtractionHelpers/__tests__/testArrayExtractorFromPage.spec.js

@@ -69,10 +69,10 @@ _extendedTest.describe.skip("Array Extractor from Page Caching Tests", () => {
         label: testLabel,
         itemEntitySchema,
         strategy: {
-          model: "claude-3-5-sonnet-20240620",
+          model: "claude-3-5-haiku-20241022",
           type: "HTML"
         },
-        variantKey: variantKey,
+        variantKey,
         apiKey: process.env.ANTHROPIC_API_KEY
       };
       await page.setContent(productListTemplate);
@@ -126,5 +126,274 @@ _extendedTest.describe.skip("Array Extractor from Page Caching Tests", () => {
       (0, _extendedTest.expect)(fourthResult[0]).toHaveProperty("price", "$1099");
       console.log("All cache behavior tests completed successfully!");
     });
+    (0, _extendedTest.test)("should demonstrate caching behavior with different types of DOM changes", async ({
+      page
+    }) => {
+      await page.goto("https://vendor.myfloridamarketplace.com/search/bids/detail/9507", {
+        timeout: 0
+      });
+      const result = await (0, _.extractArrayFromPage)(page, {
+        label: "external website links.",
+        itemEntityName: "downloadable_links",
+        itemEntitySchema: {
+          type: "object",
+          required: ["anchor_innerText"],
+          properties: {
+            anchor_href: {
+              type: "string",
+              description: "extract all downloadable files hrefs."
+            },
+            anchor_innerText: {
+              primary: true,
+              type: "string",
+              description: "extract title attribute of that anchor.k"
+            }
+          }
+        },
+        strategy: {
+          type: "HTML",
+          model: "claude-3-5-haiku-20241022"
+        }
+      });
+      console.log("Result:", result);
+    });
+  });
+  (0, _extendedTest.describe)("Edge Cases - Item Count Variations", () => {
+    (0, _extendedTest.test)("should handle extraction with 0 items", async ({
+      page
+    }) => {
+      const testLabel = `product-list-0-items-${(0, _uuid.v4)()}`;
+      const emptyListTemplate = `
+        <div class="products-container">
+          <div class="additional-info">
+            <div class="shipping-notice">No products available</div>
+            <div class="return-policy">Check back later</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          }
+        }
+      };
+      await page.setContent(emptyListTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("0 items result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(0);
+      (0, _extendedTest.expect)(Array.isArray(result)).toBe(true);
+    });
+    (0, _extendedTest.test)("should handle extraction with 1 item", async ({
+      page
+    }) => {
+      const testLabel = `product-list-1-item-${(0, _uuid.v4)()}`;
+      const singleItemTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">MacBook Pro M3</h2>
+            <div class="price-wrapper">
+              <span class="price">$2499</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Professional laptop with M3 Max chip</p>
+            </div>
+          </div>
+          <div class="additional-info">
+            <div class="shipping-notice">Free express shipping</div>
+            <div class="return-policy">30-day return policy</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      await page.setContent(singleItemTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("1 item result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(1);
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("title", "MacBook Pro M3");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("price", "$2499");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("description", "Professional laptop with M3 Max chip");
+    });
+    (0, _extendedTest.test)("should handle extraction with 2 items", async ({
+      page
+    }) => {
+      const testLabel = `product-list-2-items-${(0, _uuid.v4)()}`;
+      const twoItemsTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">iPad Pro</h2>
+            <div class="price-wrapper">
+              <span class="price">$1099</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Powerful tablet with M2 chip</p>
+            </div>
+          </div>
+          <div class="product-item">
+            <h2 class="product-title">Apple Watch Ultra</h2>
+            <div class="price-wrapper">
+              <span class="price">$799</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Rugged smartwatch for athletes</p>
+            </div>
+          </div>
+          <div class="additional-info">
+            <div class="shipping-notice">Free shipping on all orders</div>
+            <div class="return-policy">30-day return policy</div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          },
+          description: {
+            type: "string",
+            description: "Product description"
+          }
+        }
+      };
+      await page.setContent(twoItemsTemplate);
+      const result = await (0, _.extractArrayFromPage)(page, {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      });
+      console.log("2 items result:", result);
+      (0, _extendedTest.expect)(result).toHaveLength(2);
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("title", "iPad Pro");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("price", "$1099");
+      (0, _extendedTest.expect)(result[0]).toHaveProperty("description", "Powerful tablet with M2 chip");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("title", "Apple Watch Ultra");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("price", "$799");
+      (0, _extendedTest.expect)(result[1]).toHaveProperty("description", "Rugged smartwatch for athletes");
+    });
+    (0, _extendedTest.test)("should cache and reuse results for 1 item correctly", async ({
+      page
+    }) => {
+      const testLabel = `product-list-1-item-cache-${(0, _uuid.v4)()}`;
+      const singleItemTemplate = `
+        <div class="products-container">
+          <div class="product-item">
+            <h2 class="product-title">Sony WH-1000XM5</h2>
+            <div class="price-wrapper">
+              <span class="price">$399</span>
+            </div>
+            <div class="details">
+              <p class="product-description">Premium noise-canceling headphones</p>
+            </div>
+          </div>
+        </div>
+      `;
+      const itemEntitySchema = {
+        type: "object",
+        required: ["title", "price"],
+        properties: {
+          title: {
+            type: "string",
+            description: "Product title",
+            primary: true
+          },
+          price: {
+            type: "string",
+            description: "Product price"
+          }
+        }
+      };
+      const extractionOptions = {
+        itemEntityName: "product",
+        label: testLabel,
+        itemEntitySchema,
+        strategy: {
+          model: "claude-3-5-haiku-20241022",
+          type: "HTML"
+        },
+        variantKey: testLabel,
+        apiKey: process.env.ANTHROPIC_API_KEY
+      };
+      await page.setContent(singleItemTemplate);
+      const firstResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("First extraction (1 item):", firstResult);
+      (0, _extendedTest.expect)(firstResult).toHaveLength(1);
+      (0, _extendedTest.expect)(firstResult[0]).toHaveProperty("title", "Sony WH-1000XM5");
+      (0, _extendedTest.expect)(firstResult[0]).toHaveProperty("price", "$399");
+      await page.setContent(singleItemTemplate);
+      const secondResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("Second extraction (from cache, 1 item):", secondResult);
+      (0, _extendedTest.expect)(secondResult).toEqual(firstResult);
+      (0, _extendedTest.expect)(secondResult).toHaveLength(1);
+      (0, _extendedTest.expect)(secondResult[0]).toHaveProperty("title", "Sony WH-1000XM5");
+      (0, _extendedTest.expect)(secondResult[0]).toHaveProperty("price", "$399");
+      const modifiedTemplate = singleItemTemplate.replace("Sony WH-1000XM5", "Bose QuietComfort Ultra").replace("$399", "$429");
+      await page.setContent(modifiedTemplate);
+      const thirdResult = await (0, _.extractArrayFromPage)(page, extractionOptions);
+      console.log("Third extraction (changed content, 1 item):", thirdResult);
+      (0, _extendedTest.expect)(thirdResult).not.toEqual(firstResult);
+      (0, _extendedTest.expect)(thirdResult).toHaveLength(1);
+      (0, _extendedTest.expect)(thirdResult[0]).toHaveProperty("title", "Bose QuietComfort Ultra");
+      (0, _extendedTest.expect)(thirdResult[0]).toHaveProperty("price", "$429");
+    });
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intuned/browser-dev",
-  "version": "0.1.5-dev.0",
+  "version": "0.1.5-dev.1",
   "description": "runner package for intuned functions",
   "types": "./dist/index.d.ts",
   "typesVersions": {
@@ -76,7 +76,7 @@
     "openai": "4.77.3",
     "stack-utils": "2.0.6",
     "tslib": "2.6.0",
-    "uuid": "13.0.0",
+    "uuid": "11.0.0",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.6",
     "zod-validation-error": "3.0.3"