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

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

@@ -23,10 +23,10 @@ var _extendedTest = require("../../common/extendedTest");
         age: 30,
         extra_field: "allowed"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with invalid data (missing required field)", async () => {
       const schema = {
@@ -44,12 +44,12 @@ var _extendedTest = require("../../common/extendedTest");
       const invalidData = {
         name: "John Doe"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
@@ -84,10 +84,10 @@ var _extendedTest = require("../../common/extendedTest");
         age: 25,
         other: "value"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with list containing invalid object", async () => {
       const schema = {
@@ -112,12 +112,12 @@ var _extendedTest = require("../../common/extendedTest");
         name: "Jane Doe",
         age: "25"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
@@ -128,7 +128,7 @@ var _extendedTest = require("../../common/extendedTest");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
-    (0, _extendedTest.test)("should validate data using schema with attachment custom type", async () => {
+    (0, _extendedTest.test)("should validate data using schema with attachment type", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -146,18 +146,19 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "documents/report.pdf",
           bucket: "my-bucket",
           region: "us-east-1",
+          key: "documents/report.pdf",
           endpoint: null,
           suggestedFileName: "Monthly Report.pdf",
           fileType: "document"
         },
         name: "Test File Upload"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
-    (0, _extendedTest.test)("should validate data using schema with invalid attachment custom type", async () => {
+    (0, _extendedTest.test)("should validate data using schema with invalid attachment type", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -176,19 +177,18 @@ var _extendedTest = require("../../common/extendedTest");
         },
         name: "Test File Upload"
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
         (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
-        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -213,6 +213,7 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc1.pdf",
           bucket: "bucket1",
           region: "us-east-1",
+          key: "files/doc1.pdf",
           suggestedFileName: "Document 1.pdf"
         },
         description: "First document"
@@ -221,14 +222,15 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc2.pdf",
           bucket: "bucket2",
           region: "us-west-2",
+          key: "files/doc2.pdf",
           suggestedFileName: "Document 2.pdf"
         },
         description: "Second document"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
     });
     (0, _extendedTest.test)("should validate data using schema with invalid attachment in array", async () => {
       const schema = {
@@ -251,6 +253,7 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "doc1.pdf",
           bucket: "bucket1",
           region: "us-east-1",
+          key: "files/doc1.pdf",
           suggestedFileName: "Document 1.pdf"
         },
         description: "First document"
@@ -260,23 +263,22 @@ var _extendedTest = require("../../common/extendedTest");
         },
         description: "Second document"
       }];
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       try {
-        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
           data: invalidData,
           schema
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
         (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
-        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
-    (0, _extendedTest.test)("should handle mixed custom and standard types", async () => {
+    (0, _extendedTest.test)("should handle mixed attachment and standard types", async () => {
       const schema = {
         type: "object",
         properties: {
@@ -300,31 +302,33 @@ var _extendedTest = require("../../common/extendedTest");
           fileName: "mixed-test.pdf",
           bucket: "test-bucket",
           region: "us-east-1",
+          key: "files/mixed-test.pdf",
           suggestedFileName: "Mixed Test.pdf"
         },
         title: "Mixed validation test",
         count: 42,
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: validData,
         schema
-      })).resolves.not.toThrow();
+      })).not.toThrow();
       const invalidStandardData = {
         attachment: {
           fileName: "mixed-test.pdf",
           bucket: "test-bucket",
           region: "us-east-1",
+          key: "files/mixed-test.pdf",
           suggestedFileName: "Mixed Test.pdf"
         },
         title: "Mixed validation test",
         count: "not-a-number",
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidStandardData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
       const invalidCustomData = {
         attachment: {
           fileName: "mixed-test.pdf"
@@ -333,10 +337,10 @@ var _extendedTest = require("../../common/extendedTest");
         count: 42,
         active: true
       };
-      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
         data: invalidCustomData,
         schema
-      })).rejects.toThrow(_types.ValidationError);
+      })).toThrow(_types.ValidationError);
     });
   });
 });

package/dist/helpers/types/Attachment.js

@@ -12,16 +12,18 @@ var _zod = require("zod");
 const AttachmentTypeSchema = exports.AttachmentTypeSchema = _zod.z.literal("document");
 const AttachmentSchema = exports.AttachmentSchema = _zod.z.object({
   fileName: _zod.z.string(),
+  key: _zod.z.string(),
   bucket: _zod.z.string(),
   region: _zod.z.string(),
   suggestedFileName: _zod.z.string(),
-  endpoint: _zod.z.string().optional(),
-  fileType: AttachmentTypeSchema.optional()
+  endpoint: _zod.z.string().nullable().optional(),
+  fileType: AttachmentTypeSchema.optional().nullable()
 });
 class Attachment {
-  constructor(fileName, bucket, region, suggestedFileName, endpoint, fileType) {
+  constructor(fileName, key, bucket, region, suggestedFileName, endpoint, fileType) {
     const validatedData = AttachmentSchema.parse({
       fileName,
+      key,
       bucket,
       region,
       suggestedFileName,
@@ -29,8 +31,10 @@ class Attachment {
       fileType
     });
     this.fileName = validatedData.fileName;
+    this.key = validatedData.key;
     this.bucket = validatedData.bucket;
     this.region = validatedData.region;
+    this.key = validatedData.key;
     this.suggestedFileName = validatedData.suggestedFileName;
     this.endpoint = validatedData.endpoint;
     this.fileType = validatedData.fileType;
@@ -41,6 +45,7 @@ class Attachment {
   toDict() {
     return {
       fileName: this.fileName,
+      key: this.key,
       bucket: this.bucket,
       region: this.region,
       suggestedFileName: this.suggestedFileName,
@@ -54,13 +59,13 @@ class Attachment {
   }
   static fromDict(data) {
     const validatedData = AttachmentSchema.parse(data);
-    return new Attachment(validatedData.fileName, validatedData.bucket, validatedData.region, validatedData.suggestedFileName, validatedData.endpoint, validatedData.fileType);
+    return new Attachment(validatedData.fileName, validatedData.key, validatedData.bucket, validatedData.region, validatedData.suggestedFileName, validatedData.endpoint, validatedData.fileType);
   }
   async getSignedUrl(expiration = 3600 * 24 * 5) {
     if ((0, _utils.isGenerateCodeMode)()) {
       return "https://not.real.com";
     }
-    const s3Client = (0, _getS3Client.getS3Client)(this.endpoint, this.region);
+    const s3Client = (0, _getS3Client.getS3Client)(this.endpoint ?? undefined, this.region);
     try {
       const response = await (0, _s3RequestPresigner.getSignedUrl)(s3Client, new _clientS.GetObjectCommand({
         Bucket: this.bucket,
@@ -94,7 +99,7 @@ class SignedUrlAttachment extends Attachment {
     const bucket = url.hostname.split(".")[0];
     const key = url.pathname.substring(1);
     const validatedUrl = _zod.z.string().url().parse(downloadSignedUrl);
-    super(key, bucket, "", suggestedFileName ?? fileName);
+    super(fileName, key, bucket, "", suggestedFileName ?? fileName);
     this.downloadSignedUrl = validatedUrl;
   }
   async getSignedUrl() {

package/dist/helpers/types/index.js

@@ -9,24 +9,6 @@ Object.defineProperty(exports, "Attachment", {
     return _Attachment.Attachment;
   }
 });
-Object.defineProperty(exports, "AttachmentValidator", {
-  enumerable: true,
-  get: function () {
-    return _CustomTypeRegistry.AttachmentValidator;
-  }
-});
-Object.defineProperty(exports, "CustomTypeRegistry", {
-  enumerable: true,
-  get: function () {
-    return _CustomTypeRegistry.CustomTypeRegistry;
-  }
-});
-Object.defineProperty(exports, "CustomTypeValidator", {
-  enumerable: true,
-  get: function () {
-    return _CustomTypeRegistry.CustomTypeValidator;
-  }
-});
 Object.defineProperty(exports, "RunEnvironment", {
   enumerable: true,
   get: function () {
@@ -47,5 +29,4 @@ Object.defineProperty(exports, "ValidationError", {
 });
 var _ValidationError = require("./ValidationError");
 var _RunEnvironment = require("./RunEnvironment");
-var _Attachment = require("./Attachment");
-var _CustomTypeRegistry = require("./CustomTypeRegistry");
+var _Attachment = require("./Attachment");

package/dist/helpers/uploadFileToS3.js

@@ -51,7 +51,7 @@ const uploadFileToS3 = async input => {
   if ((0, _utils.isGenerateCodeMode)()) {
     console.log("Uploaded file successfully");
     if (isDownloadedFile) {
-      return new _Attachment.Attachment(`${(0, _uuid.v4)()}/${file.suggestedFilename()}`, "testing_bucket", "testing_region", file.suggestedFilename() || "downloaded_file", endpoint, "document");
+      return new _Attachment.Attachment(`${(0, _uuid.v4)()}/${file.suggestedFilename()}`, `${(0, _uuid.v4)()}/${file.suggestedFilename()}`, "testing_bucket", "testing_region", file.suggestedFilename() || "downloaded_file", endpoint, "document");
     }
   }
   let suggestedFileName;
@@ -93,7 +93,7 @@ const uploadFileToS3 = async input => {
     });
     const response = await s3Client.send(command);
     if (response.$metadata.httpStatusCode === 200) {
-      return new _Attachment.Attachment(key, bucketName, region, suggestedFileName || fileName, endpoint);
+      return new _Attachment.Attachment(key, key, bucketName, region, suggestedFileName || fileName, endpoint);
     } else {
       throw new Error("Error uploading file");
     }

package/dist/helpers/validateDataUsingSchema.js

@@ -3,99 +3,58 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.injectAttachmentType = injectAttachmentType;
 exports.validateDataUsingSchema = void 0;
 var _ajv = _interopRequireDefault(require("ajv"));
+var _zodToJsonSchema = require("zod-to-json-schema");
 var _types = require("./types");
+var _Attachment = require("./types/Attachment");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const ajv = new _ajv.default({
   strict: false,
   removeAdditional: false
 });
-ajv.addKeyword({
-  keyword: "x-custom-type",
-  schemaType: "string",
-  compile: () => () => true
-});
-const customTypeRegistry = new _types.CustomTypeRegistry();
-function preprocessSchema(schema) {
-  if (typeof schema !== "object" || schema === null) {
-    return schema;
-  }
-  if (Array.isArray(schema)) {
-    return schema.map(item => preprocessSchema(item));
-  }
-  const processedSchema = {
-    ...schema
-  };
-  if (processedSchema.type && typeof processedSchema.type === "string") {
-    if (customTypeRegistry.isCustomType(processedSchema.type)) {
-      return {
-        type: "object",
-        additionalProperties: true,
-        "x-custom-type": processedSchema.type
-      };
+function injectAttachmentType(schema) {
+  const schemaCopy = JSON.parse(JSON.stringify(schema));
+  const attachmentJsonSchema = (0, _zodToJsonSchema.zodToJsonSchema)(_Attachment.AttachmentSchema, {
+    $refStrategy: "none"
+  });
+  const attachmentDefinition = typeof attachmentJsonSchema === "object" && attachmentJsonSchema !== null ? attachmentJsonSchema : {};
+  if (!schemaCopy.$defs) {
+    schemaCopy.$defs = {};
+  }
+  schemaCopy.$defs.attachment = attachmentDefinition;
+  function replaceAttachmentType(node) {
+    if (typeof node !== "object" || node === null) {
+      return node;
     }
-  }
-  for (const key in processedSchema) {
-    if (key === "properties" && typeof processedSchema[key] === "object") {
-      const newProperties = {};
-      for (const propKey in processedSchema[key]) {
-        newProperties[propKey] = preprocessSchema(processedSchema[key][propKey]);
-      }
-      processedSchema[key] = newProperties;
-    } else if (key === "items") {
-      processedSchema[key] = preprocessSchema(processedSchema[key]);
-    } else if (typeof processedSchema[key] === "object") {
-      processedSchema[key] = preprocessSchema(processedSchema[key]);
+    if (Array.isArray(node)) {
+      return node.map(item => replaceAttachmentType(item));
     }
-  }
-  return processedSchema;
-}
-function validateCustomTypes(data, schema, path = "root") {
-  const errors = [];
-  if (typeof schema !== "object" || schema === null) {
-    return errors;
-  }
-  if (schema["x-custom-type"]) {
-    const customType = schema["x-custom-type"];
-    if (!customTypeRegistry.validate(customType, data)) {
-      errors.push(`${path} does not match custom type '${customType}'`);
+    const result = {};
+    if (node.type === "attachment") {
+      return {
+        $ref: "#/$defs/attachment"
+      };
     }
-    return errors;
-  }
-  if (schema.type === "object" && schema.properties && typeof data === "object" && data !== null && !Array.isArray(data)) {
-    for (const [propKey, propSchema] of Object.entries(schema.properties)) {
-      if (Object.prototype.hasOwnProperty.call(data, propKey)) {
-        const propPath = path === "root" ? propKey : `${path}.${propKey}`;
-        errors.push(...validateCustomTypes(data[propKey], propSchema, propPath));
-      }
+    for (const key in node) {
+      result[key] = replaceAttachmentType(node[key]);
     }
+    return result;
   }
-  if (schema.type === "array" && schema.items && Array.isArray(data)) {
-    data.forEach((item, index) => {
-      const itemPath = `${path}[${index}]`;
-      errors.push(...validateCustomTypes(item, schema.items, itemPath));
-    });
-  }
-  return errors;
+  return replaceAttachmentType(schemaCopy);
 }
-const validateDataUsingSchema = async input => {
+const validateDataUsingSchema = input => {
   const {
     data,
     schema
   } = input;
-  const processedSchema = preprocessSchema(schema);
+  const processedSchema = injectAttachmentType(schema);
   const validate = ajv.compile(processedSchema);
   const valid = validate(data);
-  const errors = [];
   if (!valid) {
     var _validate$errors;
-    const schemaErrors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`).filter(error => !error.includes("x-custom-type"))) || [];
-    errors.push(...schemaErrors);
-  }
-  const customTypeErrors = validateCustomTypes(data, processedSchema);
-  errors.push(...customTypeErrors);
-  if (errors.length > 0) {
+    const errors = ((_validate$errors = validate.errors) === null || _validate$errors === void 0 ? void 0 : _validate$errors.map(err => `${err.instancePath || "root"} ${err.message}`)) || [];
     const errorMessage = errors.join(", ") || "Unknown validation error";
     throw new _types.ValidationError(`Data validation failed: ${errorMessage}`, data);
   }

package/dist/intunedServices/ApiGateway/tests/testApiGateway.spec.js

@@ -63,15 +63,15 @@ const mockLoadRuntime = _vitest.vi.mocked(_loadRuntime.loadRuntime);
     (0, _extendedTest.it)("should use default model when not provided", () => {
       const gateway = new _aiApiGateway.APIGateway({
         apiKey: "sk-test123",
-        model: "gpt-4o-2024-08-06"
+        model: "gpt-5-mini-2025-08-07"
       });
-      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-5-mini-2025-08-07");
     });
     (0, _extendedTest.it)("should allow no parameters", () => {
       const gateway = new _aiApiGateway.APIGateway({
-        model: "gpt-4o-2024-08-06"
+        model: "gpt-5-mini-2025-08-07"
       });
-      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-4o-2024-08-06");
+      (0, _extendedTest.expect)(gateway["model"]).toBe("gpt-5-mini-2025-08-07");
       (0, _extendedTest.expect)(gateway["apiKey"]).toBeUndefined();
     });
   });

package/dist/optimized-extractors/listExtractionHelpers/runAiExtraction.js

@@ -70,16 +70,63 @@ async function handleNewAiExtraction(params) {
     allData.value.forEach((v, i) => {
       _Logger.logger.debug(`ai extraction result for row ${i}: ${JSON.stringify(v)}`);
     });
-    const aiResults = allData.value.map((v, i) => ({
-      result: v,
-      rowIndex: i
-    }));
-    const resultValues = aiResults;
-    const matches = await (0, _getListMatches.getListMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, aiResults);
+    const resultValues = [];
+    for (let i = 0; i < allData.value.length; i++) {
+      const rowValues = allData.value[i];
+      const allValues = Object.entries(rowValues).map(([_, value]) => value);
+      const rowValuesMatches = await (0, _findDomMatches.getDomMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, allValues);
+      const rowValuesWithMatchesOnly = Object.entries(rowValues).reduce((acc, [key, value]) => {
+        const valueMatches = rowValuesMatches.get(value);
+        const bestMatch = (0, _utils.selectBestMatch)(value, valueMatches ?? []);
+        if (valueMatches && valueMatches.length > 0 && bestMatch) {
+          acc[key] = {
+            matchText: bestMatch.matchText,
+            matchXpath: bestMatch.matchXpath,
+            matchType: bestMatch.matchType
+          };
+        } else {
+          _Logger.logger.debug(`value "${value}" for key "${key}" in row ${i + 1} does not have any matches in the page html, dropped for hallucination protection`);
+        }
+        return acc;
+      }, {});
+      resultValues.push({
+        rowIndex: i,
+        result: rowValuesWithMatchesOnly
+      });
+    }
+    const matches = await (0, _getListMatches.getListMatches)(pageAndSearchRegion.page, pageAndSearchRegion.searchRegionHandler, resultValues.map(v => ({
+      rowIndex: v.rowIndex,
+      result: Object.fromEntries(Object.entries(v.result).map(([key, value]) => [key, value.matchText]))
+    })));
+    let containerPath = null;
+    let fullContainerXpath = null;
+    if (resultValues.length > 0 && resultValues[0].result[primaryPropertyName]) {
+      const primaryXpath = resultValues[0].result[primaryPropertyName].matchXpath;
+      if (primaryXpath) {
+        const parentXpath = await pageAndSearchRegion.page.evaluate(xpath => {
+          var _window$__INTUNED__;
+          const result = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null);
+          const element = result.singleNodeValue;
+          if (!element || !element.parentElement) return null;
+          if ((_window$__INTUNED__ = window.__INTUNED__) !== null && _window$__INTUNED__ !== void 0 && _window$__INTUNED__.getElementXPath) {
+            return window.__INTUNED__.getElementXPath(element.parentElement);
+          }
+          return null;
+        }, primaryXpath);
+        if (parentXpath) {
+          fullContainerXpath = parentXpath;
+          if (hasSearchRegionContainer) {
+            containerPath = await (0, _getRelativeContainerXpathSelector.getRelativeContainerXpathSelector)(pageAndSearchRegion.searchRegion, parentXpath);
+          } else {
+            containerPath = parentXpath;
+          }
+        }
+      }
+    }
     return (0, _neverthrow.ok)({
       resultValues,
-      containerPath: null,
-      fullContainerXpath: null,
+      containerPath,
+      fullContainerXpath,
       matches
     });
   }

package/generated-docs/ai/functions/extractStructuredData.mdx

@@ -34,7 +34,7 @@ await page.goto("https://books.toscrape.com/")
 const product = await extractStructuredData({
   source: page,
   strategy: "HTML",
-  model: "gpt-4o"
+  model: "gpt-4o",
   dataSchema: {
     type: "object",
     properties: {
@@ -47,8 +47,8 @@ const product = await extractStructuredData({
   },
   prompt: "Extract product details from this e page"
 });
-}
 console.log(`Found book: ${product.name} - ${product.price}`);
+}
 ```
 
 ```typescript Locator source
@@ -59,7 +59,7 @@ const articleContainer = page.locator("article").first()
 const article = await extractStructuredData({
   source: articleContainer,
   strategy: "MARKDOWN",
-  model: "claude-3",
+  model: "claude-3-5-sonnet-20240620",
   dataSchema: {
   type: "object",
   properties: {
@@ -72,8 +72,8 @@ const article = await extractStructuredData({
 },
   maxRetries: 5
 });
-}
 console.log(`Found book: ${article.title}`);
+}
 ```
 
 </CodeGroup>
@@ -138,7 +138,7 @@ export declare function extractStructuredData(options: {
   content: ContentItem[] | ContentItem;
   dataSchema: JsonSchema | z.ZodSchema;
   prompt?: string;
-  maxRetires?: number;
+  maxRetries?: number;
   enableCache?: boolean;
   model: SUPPORTED_MODELS;
   apiKey?: string;

package/generated-docs/ai/functions/isPageLoaded.mdx

@@ -51,6 +51,7 @@ while (attempts < 10) {
   await page.waitForTimeout(2000);
   attempts++;
 }
+}
 ```
 }