@browserbasehq/orca 3.0.9-alpha-4 → 3.1.0-patch.1

package/dist/cjs/tests/public-api/public-error-types.test.js

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var public_error_types_test_exports = {};
+__export(public_error_types_test_exports, {
+  publicErrorTypes: () => publicErrorTypes
+});
+module.exports = __toCommonJS(public_error_types_test_exports);
+var import_vitest = require("vitest");
+var Stagehand = __toESM(require("@browserbasehq/stagehand"), 1);
+const publicErrorTypes = {
+  AgentAbortError: Stagehand.AgentAbortError,
+  AgentScreenshotProviderError: Stagehand.AgentScreenshotProviderError,
+  BrowserbaseSessionNotFoundError: Stagehand.BrowserbaseSessionNotFoundError,
+  CaptchaTimeoutError: Stagehand.CaptchaTimeoutError,
+  ConnectionTimeoutError: Stagehand.ConnectionTimeoutError,
+  ContentFrameNotFoundError: Stagehand.ContentFrameNotFoundError,
+  CreateChatCompletionResponseError: Stagehand.CreateChatCompletionResponseError,
+  CuaModelRequiredError: Stagehand.CuaModelRequiredError,
+  ElementNotVisibleError: Stagehand.ElementNotVisibleError,
+  ExperimentalApiConflictError: Stagehand.ExperimentalApiConflictError,
+  ExperimentalNotConfiguredError: Stagehand.ExperimentalNotConfiguredError,
+  HandlerNotInitializedError: Stagehand.HandlerNotInitializedError,
+  InvalidAISDKModelFormatError: Stagehand.InvalidAISDKModelFormatError,
+  LLMResponseError: Stagehand.LLMResponseError,
+  MCPConnectionError: Stagehand.MCPConnectionError,
+  MissingEnvironmentVariableError: Stagehand.MissingEnvironmentVariableError,
+  MissingLLMConfigurationError: Stagehand.MissingLLMConfigurationError,
+  PageNotFoundError: Stagehand.PageNotFoundError,
+  ResponseBodyError: Stagehand.ResponseBodyError,
+  ResponseParseError: Stagehand.ResponseParseError,
+  StagehandAPIError: Stagehand.StagehandAPIError,
+  StagehandAPIUnauthorizedError: Stagehand.StagehandAPIUnauthorizedError,
+  StagehandClickError: Stagehand.StagehandClickError,
+  StagehandClosedError: Stagehand.StagehandClosedError,
+  StagehandDefaultError: Stagehand.StagehandDefaultError,
+  StagehandDomProcessError: Stagehand.StagehandDomProcessError,
+  StagehandElementNotFoundError: Stagehand.StagehandElementNotFoundError,
+  StagehandEnvironmentError: Stagehand.StagehandEnvironmentError,
+  StagehandError: Stagehand.StagehandError,
+  StagehandEvalError: Stagehand.StagehandEvalError,
+  StagehandHttpError: Stagehand.StagehandHttpError,
+  StagehandIframeError: Stagehand.StagehandIframeError,
+  StagehandInitError: Stagehand.StagehandInitError,
+  StagehandInvalidArgumentError: Stagehand.StagehandInvalidArgumentError,
+  StagehandLocatorError: Stagehand.StagehandLocatorError,
+  StagehandMissingArgumentError: Stagehand.StagehandMissingArgumentError,
+  StagehandNotInitializedError: Stagehand.StagehandNotInitializedError,
+  StagehandResponseBodyError: Stagehand.StagehandResponseBodyError,
+  StagehandResponseParseError: Stagehand.StagehandResponseParseError,
+  StagehandServerError: Stagehand.StagehandServerError,
+  StagehandShadowRootMissingError: Stagehand.StagehandShadowRootMissingError,
+  StagehandShadowSegmentEmptyError: Stagehand.StagehandShadowSegmentEmptyError,
+  StagehandShadowSegmentNotFoundError: Stagehand.StagehandShadowSegmentNotFoundError,
+  StreamingCallbacksInNonStreamingModeError: Stagehand.StreamingCallbacksInNonStreamingModeError,
+  StagehandSnapshotError: Stagehand.StagehandSnapshotError,
+  TimeoutError: Stagehand.TimeoutError,
+  UnsupportedAISDKModelProviderError: Stagehand.UnsupportedAISDKModelProviderError,
+  UnsupportedModelError: Stagehand.UnsupportedModelError,
+  UnsupportedModelProviderError: Stagehand.UnsupportedModelProviderError,
+  XPathResolutionError: Stagehand.XPathResolutionError,
+  ZodSchemaValidationError: Stagehand.ZodSchemaValidationError,
+  ActTimeoutError: Stagehand.ActTimeoutError,
+  ObserveTimeoutError: Stagehand.ObserveTimeoutError,
+  ExtractTimeoutError: Stagehand.ExtractTimeoutError
+};
+const errorTypes = Object.keys(publicErrorTypes);
+(0, import_vitest.describe)("Stagehand public error types", () => {
+  (0, import_vitest.describe)("errors", () => {
+    import_vitest.it.each(errorTypes)("%s extends Error", (errorTypeName) => {
+      const ErrorClass = Stagehand[errorTypeName];
+      (0, import_vitest.expectTypeOf)().toExtend();
+    });
+  });
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  publicErrorTypes
+});
+//# sourceMappingURL=public-error-types.test.js.map

package/dist/cjs/tests/public-api/public-error-types.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/public-error-types.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\nexport const publicErrorTypes = {\n  AgentAbortError: Stagehand.AgentAbortError,\n  AgentScreenshotProviderError: Stagehand.AgentScreenshotProviderError,\n  BrowserbaseSessionNotFoundError: Stagehand.BrowserbaseSessionNotFoundError,\n  CaptchaTimeoutError: Stagehand.CaptchaTimeoutError,\n  ConnectionTimeoutError: Stagehand.ConnectionTimeoutError,\n  ContentFrameNotFoundError: Stagehand.ContentFrameNotFoundError,\n  CreateChatCompletionResponseError:\n    Stagehand.CreateChatCompletionResponseError,\n  CuaModelRequiredError: Stagehand.CuaModelRequiredError,\n  ElementNotVisibleError: Stagehand.ElementNotVisibleError,\n  ExperimentalApiConflictError: Stagehand.ExperimentalApiConflictError,\n  ExperimentalNotConfiguredError: Stagehand.ExperimentalNotConfiguredError,\n  HandlerNotInitializedError: Stagehand.HandlerNotInitializedError,\n  InvalidAISDKModelFormatError: Stagehand.InvalidAISDKModelFormatError,\n  LLMResponseError: Stagehand.LLMResponseError,\n  MCPConnectionError: Stagehand.MCPConnectionError,\n  MissingEnvironmentVariableError: Stagehand.MissingEnvironmentVariableError,\n  MissingLLMConfigurationError: Stagehand.MissingLLMConfigurationError,\n  PageNotFoundError: Stagehand.PageNotFoundError,\n  ResponseBodyError: Stagehand.ResponseBodyError,\n  ResponseParseError: Stagehand.ResponseParseError,\n  StagehandAPIError: Stagehand.StagehandAPIError,\n  StagehandAPIUnauthorizedError: Stagehand.StagehandAPIUnauthorizedError,\n  StagehandClickError: Stagehand.StagehandClickError,\n  StagehandClosedError: Stagehand.StagehandClosedError,\n  StagehandDefaultError: Stagehand.StagehandDefaultError,\n  StagehandDomProcessError: Stagehand.StagehandDomProcessError,\n  StagehandElementNotFoundError: Stagehand.StagehandElementNotFoundError,\n  StagehandEnvironmentError: Stagehand.StagehandEnvironmentError,\n  StagehandError: Stagehand.StagehandError,\n  StagehandEvalError: Stagehand.StagehandEvalError,\n  StagehandHttpError: Stagehand.StagehandHttpError,\n  StagehandIframeError: Stagehand.StagehandIframeError,\n  StagehandInitError: Stagehand.StagehandInitError,\n  StagehandInvalidArgumentError: Stagehand.StagehandInvalidArgumentError,\n  StagehandLocatorError: Stagehand.StagehandLocatorError,\n  StagehandMissingArgumentError: Stagehand.StagehandMissingArgumentError,\n  StagehandNotInitializedError: Stagehand.StagehandNotInitializedError,\n  StagehandResponseBodyError: Stagehand.StagehandResponseBodyError,\n  StagehandResponseParseError: Stagehand.StagehandResponseParseError,\n  StagehandServerError: Stagehand.StagehandServerError,\n  StagehandShadowRootMissingError: Stagehand.StagehandShadowRootMissingError,\n  StagehandShadowSegmentEmptyError: Stagehand.StagehandShadowSegmentEmptyError,\n  StagehandShadowSegmentNotFoundError:\n    Stagehand.StagehandShadowSegmentNotFoundError,\n  StreamingCallbacksInNonStreamingModeError:\n    Stagehand.StreamingCallbacksInNonStreamingModeError,\n  StagehandSnapshotError: Stagehand.StagehandSnapshotError,\n  TimeoutError: Stagehand.TimeoutError,\n  UnsupportedAISDKModelProviderError:\n    Stagehand.UnsupportedAISDKModelProviderError,\n  UnsupportedModelError: Stagehand.UnsupportedModelError,\n  UnsupportedModelProviderError: Stagehand.UnsupportedModelProviderError,\n  XPathResolutionError: Stagehand.XPathResolutionError,\n  ZodSchemaValidationError: Stagehand.ZodSchemaValidationError,\n  ActTimeoutError: Stagehand.ActTimeoutError,\n  ObserveTimeoutError: Stagehand.ObserveTimeoutError,\n  ExtractTimeoutError: Stagehand.ExtractTimeoutError,\n} as const;\n\nconst errorTypes = Object.keys(publicErrorTypes) as Array<\n  keyof typeof publicErrorTypes\n>;\n\ndescribe(\"Stagehand public error types\", () => {\n  describe(\"errors\", () => {\n    it.each(errorTypes)(\"%s extends Error\", (errorTypeName) => {\n      const ErrorClass = Stagehand[errorTypeName];\n      type ErrorClassType = typeof ErrorClass;\n      expectTypeOf<InstanceType<ErrorClassType>>().toExtend<Error>();\n      void ErrorClass; // Mark as used to satisfy ESLint\n    });\n  });\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA2C;AAC3C,gBAA2B;AAEpB,MAAM,mBAAmB;AAAA,EAC9B,iBAAiB,UAAU;AAAA,EAC3B,8BAA8B,UAAU;AAAA,EACxC,iCAAiC,UAAU;AAAA,EAC3C,qBAAqB,UAAU;AAAA,EAC/B,wBAAwB,UAAU;AAAA,EAClC,2BAA2B,UAAU;AAAA,EACrC,mCACE,UAAU;AAAA,EACZ,uBAAuB,UAAU;AAAA,EACjC,wBAAwB,UAAU;AAAA,EAClC,8BAA8B,UAAU;AAAA,EACxC,gCAAgC,UAAU;AAAA,EAC1C,4BAA4B,UAAU;AAAA,EACtC,8BAA8B,UAAU;AAAA,EACxC,kBAAkB,UAAU;AAAA,EAC5B,oBAAoB,UAAU;AAAA,EAC9B,iCAAiC,UAAU;AAAA,EAC3C,8BAA8B,UAAU;AAAA,EACxC,mBAAmB,UAAU;AAAA,EAC7B,mBAAmB,UAAU;AAAA,EAC7B,oBAAoB,UAAU;AAAA,EAC9B,mBAAmB,UAAU;AAAA,EAC7B,+BAA+B,UAAU;AAAA,EACzC,qBAAqB,UAAU;AAAA,EAC/B,sBAAsB,UAAU;AAAA,EAChC,uBAAuB,UAAU;AAAA,EACjC,0BAA0B,UAAU;AAAA,EACpC,+BAA+B,UAAU;AAAA,EACzC,2BAA2B,UAAU;AAAA,EACrC,gBAAgB,UAAU;AAAA,EAC1B,oBAAoB,UAAU;AAAA,EAC9B,oBAAoB,UAAU;AAAA,EAC9B,sBAAsB,UAAU;AAAA,EAChC,oBAAoB,UAAU;AAAA,EAC9B,+BAA+B,UAAU;AAAA,EACzC,uBAAuB,UAAU;AAAA,EACjC,+BAA+B,UAAU;AAAA,EACzC,8BAA8B,UAAU;AAAA,EACxC,4BAA4B,UAAU;AAAA,EACtC,6BAA6B,UAAU;AAAA,EACvC,sBAAsB,UAAU;AAAA,EAChC,iCAAiC,UAAU;AAAA,EAC3C,kCAAkC,UAAU;AAAA,EAC5C,qCACE,UAAU;AAAA,EACZ,2CACE,UAAU;AAAA,EACZ,wBAAwB,UAAU;AAAA,EAClC,cAAc,UAAU;AAAA,EACxB,oCACE,UAAU;AAAA,EACZ,uBAAuB,UAAU;AAAA,EACjC,+BAA+B,UAAU;AAAA,EACzC,sBAAsB,UAAU;AAAA,EAChC,0BAA0B,UAAU;AAAA,EACpC,iBAAiB,UAAU;AAAA,EAC3B,qBAAqB,UAAU;AAAA,EAC/B,qBAAqB,UAAU;AACjC;AAEA,MAAM,aAAa,OAAO,KAAK,gBAAgB;AAAA,IAI/C,wBAAS,gCAAgC,MAAM;AAC7C,8BAAS,UAAU,MAAM;AACvB,qBAAG,KAAK,UAAU,EAAE,oBAAoB,CAAC,kBAAkB;AACzD,YAAM,aAAa,UAAU,aAAa;AAE1C,sCAA2C,EAAE,SAAgB;AAAA,IAE/D,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/tests/public-api/public-types.test.js

@@ -0,0 +1,74 @@
+var import_vitest = require("vitest");
+(0, import_vitest.describe)("Stagehand public API types", () => {
+  (0, import_vitest.describe)("AnyPage", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("ActOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("ActResult", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("ExtractOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("ObserveOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("Action", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentAction", () => {
+    (0, import_vitest.it)("has type field", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentExecuteOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentStreamExecuteOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentExecutionOptions", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentResult", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("AgentConfig", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toExtend();
+    });
+  });
+  (0, import_vitest.describe)("AgentToolMode", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("HistoryEntry", () => {
+    (0, import_vitest.it)("matches expected type shape", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+});
+//# sourceMappingURL=public-types.test.js.map

package/dist/cjs/tests/public-api/public-types.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/public-types.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\n// Type-level manifest of all expected exported types\n// Since these types don't exist at runtime, we currently need to manually add new publicly exported types\n// to this list ourselves - it's not automatically going to catch changes like our export-surface.test.ts does.\n\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\ntype ExpectedExportedTypes = {\n  // Types from model.ts\n  AvailableModel: Stagehand.AvailableModel;\n  AvailableCuaModel: Stagehand.AvailableCuaModel;\n  ModelProvider: Stagehand.ModelProvider;\n  ClientOptions: Stagehand.ClientOptions;\n  ModelConfiguration: Stagehand.ModelConfiguration;\n  AnthropicJsonSchemaObject: Stagehand.AnthropicJsonSchemaObject;\n  AISDKProvider: Stagehand.AISDKProvider;\n  AISDKCustomProvider: Stagehand.AISDKCustomProvider;\n  LLMTool: Stagehand.LLMTool;\n  // Types from methods.ts\n  ActOptions: Stagehand.ActOptions;\n  ActResult: Stagehand.ActResult;\n  ExtractResult: Stagehand.ExtractResult<Stagehand.StagehandZodSchema>;\n  Action: Stagehand.Action;\n  HistoryEntry: Stagehand.HistoryEntry;\n  ExtractOptions: Stagehand.ExtractOptions;\n  ObserveOptions: Stagehand.ObserveOptions;\n  V3FunctionName: Stagehand.V3FunctionName;\n  // Types from agent.ts\n  Tool: Stagehand.Tool;\n  AgentAction: Stagehand.AgentAction;\n  AgentResult: Stagehand.AgentResult;\n  AgentExecuteOptions: Stagehand.AgentExecuteOptions;\n  AgentType: Stagehand.AgentType;\n  AgentExecutionOptions: Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>;\n  AgentHandlerOptions: Stagehand.AgentHandlerOptions;\n  ActionExecutionResult: Stagehand.ActionExecutionResult;\n  ToolUseItem: Stagehand.ToolUseItem;\n  AnthropicMessage: Stagehand.AnthropicMessage;\n  AnthropicContentBlock: Stagehand.AnthropicContentBlock;\n  AnthropicTextBlock: Stagehand.AnthropicTextBlock;\n  AnthropicToolResult: Stagehand.AnthropicToolResult;\n  ResponseItem: Stagehand.ResponseItem;\n  ComputerCallItem: Stagehand.ComputerCallItem;\n  FunctionCallItem: Stagehand.FunctionCallItem;\n  ResponseInputItem: Stagehand.ResponseInputItem;\n  AgentInstance: Stagehand.AgentInstance;\n  AgentProviderType: Stagehand.AgentProviderType;\n  AgentModelConfig: Stagehand.AgentModelConfig;\n  AgentConfig: Stagehand.AgentConfig;\n  AgentToolMode: Stagehand.AgentToolMode;\n  AgentCallbacks: Stagehand.AgentCallbacks;\n  AgentExecuteCallbacks: Stagehand.AgentExecuteCallbacks;\n  AgentStreamCallbacks: Stagehand.AgentStreamCallbacks;\n  AgentExecuteOptionsBase: Stagehand.AgentExecuteOptionsBase;\n  AgentStreamExecuteOptions: Stagehand.AgentStreamExecuteOptions;\n  ModelMessage: Stagehand.ModelMessage;\n  // Types from agent/tools\n  AgentTools: Stagehand.AgentTools;\n  AgentToolTypesMap: Stagehand.AgentToolTypesMap;\n  AgentUITools: Stagehand.AgentUITools;\n  AgentToolCall: Stagehand.AgentToolCall;\n  AgentToolResult: Stagehand.AgentToolResult;\n  // Types from logs.ts\n  LogLevel: Stagehand.LogLevel;\n  LogLine: Stagehand.LogLine;\n  Logger: Stagehand.Logger;\n  // Types from metrics.ts\n  StagehandMetrics: Stagehand.StagehandMetrics;\n  // Types from options.ts\n  V3Env: Stagehand.V3Env;\n  LocalBrowserLaunchOptions: Stagehand.LocalBrowserLaunchOptions;\n  V3Options: Stagehand.V3Options;\n  // Types from page.ts\n  AnyPage: Stagehand.AnyPage;\n  Page: Stagehand.Page;\n  PlaywrightPage: Stagehand.PlaywrightPage;\n  PatchrightPage: Stagehand.PatchrightPage;\n  PuppeteerPage: Stagehand.PuppeteerPage;\n  ConsoleListener: Stagehand.ConsoleListener;\n  LoadState: Stagehand.LoadState;\n  // Types from LLMClient.ts\n  ChatMessage: Stagehand.ChatMessage;\n  ChatMessageContent: Stagehand.ChatMessageContent;\n  ChatMessageImageContent: Stagehand.ChatMessageImageContent;\n  ChatMessageTextContent: Stagehand.ChatMessageTextContent;\n  ChatCompletionOptions: Stagehand.ChatCompletionOptions;\n  LLMResponse: Stagehand.LLMResponse;\n  CreateChatCompletionOptions: Stagehand.CreateChatCompletionOptions;\n  LLMUsage: Stagehand.LLMUsage;\n  LLMParsedResponse: Stagehand.LLMParsedResponse<Record<string, unknown>>;\n  // Types from zodCompat.ts\n  StagehandZodSchema: Stagehand.StagehandZodSchema;\n  StagehandZodObject: Stagehand.StagehandZodObject;\n  InferStagehandSchema: Stagehand.InferStagehandSchema<Stagehand.StagehandZodSchema>;\n  JsonSchemaDocument: Stagehand.JsonSchemaDocument;\n  // Types from utils.ts\n  JsonSchema: Stagehand.JsonSchema;\n  JsonSchemaProperty: Stagehand.JsonSchemaProperty;\n};\n\ndescribe(\"Stagehand public API types\", () => {\n  describe(\"AnyPage\", () => {\n    type ExpectedAnyPage =\n      | Stagehand.PlaywrightPage\n      | Stagehand.PuppeteerPage\n      | Stagehand.PatchrightPage\n      | Stagehand.Page;\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AnyPage>().toEqualTypeOf<ExpectedAnyPage>();\n    });\n  });\n\n  describe(\"ActOptions\", () => {\n    type ExpectedActOptions = {\n      model?: Stagehand.ModelConfiguration;\n      variables?: Record<string, string>;\n      timeout?: number;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ActOptions>().toEqualTypeOf<ExpectedActOptions>();\n    });\n  });\n\n  describe(\"ActResult\", () => {\n    type ExpectedActResult = {\n      success: boolean;\n      message: string;\n      actionDescription: string;\n      actions: Stagehand.Action[];\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ActResult>().toEqualTypeOf<ExpectedActResult>();\n    });\n  });\n\n  describe(\"ExtractOptions\", () => {\n    type ExpectedExtractOptions = {\n      model?: Stagehand.ModelConfiguration;\n      timeout?: number;\n      selector?: string;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ExtractOptions>().toEqualTypeOf<ExpectedExtractOptions>();\n    });\n  });\n\n  describe(\"ObserveOptions\", () => {\n    type ExpectedObserveOptions = {\n      model?: Stagehand.ModelConfiguration;\n      timeout?: number;\n      selector?: string;\n      page?: Stagehand.AnyPage;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.ObserveOptions>().toEqualTypeOf<ExpectedObserveOptions>();\n    });\n  });\n\n  describe(\"Action\", () => {\n    type ExpectedAction = {\n      selector: string;\n      description: string;\n      method?: string;\n      arguments?: string[];\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.Action>().toEqualTypeOf<ExpectedAction>();\n    });\n  });\n\n  describe(\"AgentAction\", () => {\n    // AgentAction is a separate type from Action, not an extension\n    // It has additional fields like type, reasoning, taskCompleted, etc.\n    it(\"has type field\", () => {\n      type TestAction = { type: string } & Stagehand.AgentAction;\n      expectTypeOf<TestAction[\"type\"]>().toEqualTypeOf<string>();\n    });\n  });\n\n  describe(\"AgentExecuteOptions\", () => {\n    type ExpectedAgentExecuteOptions = {\n      instruction: string;\n      maxSteps?: number;\n      page?: Stagehand.AnyPage;\n      highlightCursor?: boolean;\n      messages?: Stagehand.ModelMessage[];\n      signal?: AbortSignal;\n      excludeTools?: string[];\n      output?: Stagehand.StagehandZodObject;\n      callbacks?: Stagehand.AgentExecuteCallbacks;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentExecuteOptions>().toEqualTypeOf<ExpectedAgentExecuteOptions>();\n    });\n  });\n\n  describe(\"AgentStreamExecuteOptions\", () => {\n    type ExpectedAgentStreamExecuteOptions = {\n      instruction: string;\n      maxSteps?: number;\n      page?: Stagehand.AnyPage;\n      highlightCursor?: boolean;\n      messages?: Stagehand.ModelMessage[];\n      signal?: AbortSignal;\n      excludeTools?: string[];\n      output?: Stagehand.StagehandZodObject;\n      callbacks?: Stagehand.AgentStreamCallbacks;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentStreamExecuteOptions>().toEqualTypeOf<ExpectedAgentStreamExecuteOptions>();\n    });\n  });\n\n  describe(\"AgentExecutionOptions\", () => {\n    type ExpectedAgentExecutionOptions<T = Stagehand.AgentExecuteOptions> = {\n      options: T;\n      logger: (message: Stagehand.LogLine) => void;\n      retries?: number;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<\n        Stagehand.AgentExecutionOptions<Stagehand.AgentExecuteOptions>\n      >().toEqualTypeOf<\n        ExpectedAgentExecutionOptions<Stagehand.AgentExecuteOptions>\n      >();\n    });\n  });\n\n  describe(\"AgentResult\", () => {\n    type ExpectedAgentResult = {\n      success: boolean;\n      message: string;\n      actions: Stagehand.AgentAction[];\n      completed: boolean;\n      metadata?: Record<string, unknown>;\n      usage?: {\n        input_tokens: number;\n        output_tokens: number;\n        reasoning_tokens?: number;\n        cached_input_tokens?: number;\n        inference_time_ms: number;\n      };\n      messages?: Stagehand.ModelMessage[];\n      output?: Record<string, unknown>;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentResult>().toEqualTypeOf<ExpectedAgentResult>();\n    });\n  });\n\n  describe(\"AgentConfig\", () => {\n    type ExpectedAgentConfig = {\n      systemPrompt?: string;\n      integrations?: (unknown | string)[];\n      tools?: unknown;\n      cua?: boolean;\n      model?: string | Stagehand.AgentModelConfig<string>;\n      executionModel?: string | Stagehand.AgentModelConfig<string>;\n      stream?: boolean;\n      mode?: Stagehand.AgentToolMode;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentConfig>().toExtend<ExpectedAgentConfig>();\n    });\n  });\n\n  describe(\"AgentToolMode\", () => {\n    type ExpectedAgentToolMode = \"dom\" | \"hybrid\" | \"cua\";\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.AgentToolMode>().toEqualTypeOf<ExpectedAgentToolMode>();\n    });\n  });\n\n  describe(\"HistoryEntry\", () => {\n    type ExpectedHistoryEntry = {\n      method: \"act\" | \"extract\" | \"observe\" | \"navigate\" | \"agent\";\n      parameters: unknown;\n      result: unknown;\n      timestamp: string;\n    };\n\n    it(\"matches expected type shape\", () => {\n      expectTypeOf<Stagehand.HistoryEntry>().toEqualTypeOf<ExpectedHistoryEntry>();\n    });\n  });\n});\n"],
+  "mappings": "AAAA,oBAA2C;AAAA,IAqG3C,wBAAS,8BAA8B,MAAM;AAC3C,8BAAS,WAAW,MAAM;AAOxB,0BAAG,+BAA+B,MAAM;AACtC,sCAAgC,EAAE,cAA+B;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,cAAc,MAAM;AAQ3B,0BAAG,+BAA+B,MAAM;AACtC,sCAAmC,EAAE,cAAkC;AAAA,IACzE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,aAAa,MAAM;AAQ1B,0BAAG,+BAA+B,MAAM;AACtC,sCAAkC,EAAE,cAAiC;AAAA,IACvE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,kBAAkB,MAAM;AAQ/B,0BAAG,+BAA+B,MAAM;AACtC,sCAAuC,EAAE,cAAsC;AAAA,IACjF,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,kBAAkB,MAAM;AAQ/B,0BAAG,+BAA+B,MAAM;AACtC,sCAAuC,EAAE,cAAsC;AAAA,IACjF,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,UAAU,MAAM;AAQvB,0BAAG,+BAA+B,MAAM;AACtC,sCAA+B,EAAE,cAA8B;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,eAAe,MAAM;AAG5B,0BAAG,kBAAkB,MAAM;AAEzB,sCAAiC,EAAE,cAAsB;AAAA,IAC3D,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,uBAAuB,MAAM;AAapC,0BAAG,+BAA+B,MAAM;AACtC,sCAA4C,EAAE,cAA2C;AAAA,IAC3F,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,6BAA6B,MAAM;AAa1C,0BAAG,+BAA+B,MAAM;AACtC,sCAAkD,EAAE,cAAiD;AAAA,IACvG,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,yBAAyB,MAAM;AAOtC,0BAAG,+BAA+B,MAAM;AACtC,sCAEE,EAAE,cAEF;AAAA,IACJ,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,eAAe,MAAM;AAkB5B,0BAAG,+BAA+B,MAAM;AACtC,sCAAoC,EAAE,cAAmC;AAAA,IAC3E,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,eAAe,MAAM;AAY5B,0BAAG,+BAA+B,MAAM;AACtC,sCAAoC,EAAE,SAA8B;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,iBAAiB,MAAM;AAG9B,0BAAG,+BAA+B,MAAM;AACtC,sCAAsC,EAAE,cAAqC;AAAA,IAC/E,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,gBAAgB,MAAM;AAQ7B,0BAAG,+BAA+B,MAAM;AACtC,sCAAqC,EAAE,cAAoC;AAAA,IAC7E,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/tests/public-api/runtime-utils.test.js

@@ -0,0 +1,53 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var Stagehand = __toESM(require("@browserbasehq/stagehand"), 1);
+(0, import_vitest.describe)("Runtime Utils public API types", () => {
+  (0, import_vitest.describe)("injectUrls", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.injectUrls
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("isRunningInBun", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.isRunningInBun
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("loadApiKeyFromEnv", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.loadApiKeyFromEnv
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("providerEnvVarMap", () => {
+    (0, import_vitest.it)("maps providers to environment variable names", () => {
+      (0, import_vitest.expectTypeOf)().toExtend();
+    });
+  });
+});
+//# sourceMappingURL=runtime-utils.test.js.map

package/dist/cjs/tests/public-api/runtime-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/runtime-utils.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\ndescribe(\"Runtime Utils public API types\", () => {\n  describe(\"injectUrls\", () => {\n    type ExpectedInjectUrlsParams = [\n      unknown,\n      Array<string | number>,\n      Record<string, string>,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.injectUrls,\n      ).parameters.branded.toEqualTypeOf<ExpectedInjectUrlsParams>();\n    });\n  });\n\n  describe(\"isRunningInBun\", () => {\n    type ExpectedIsRunningInBunParams = [];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isRunningInBun,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsRunningInBunParams>();\n    });\n  });\n\n  describe(\"loadApiKeyFromEnv\", () => {\n    type ExpectedLoadApiKeyFromEnvParams = [\n      string | undefined,\n      (logLine: Stagehand.LogLine) => void,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.loadApiKeyFromEnv,\n      ).parameters.branded.toEqualTypeOf<ExpectedLoadApiKeyFromEnvParams>();\n    });\n  });\n\n  describe(\"providerEnvVarMap\", () => {\n    type ExpectedProviderEnvVarMap = Partial<\n      Record<string, string | Array<string>>\n    >;\n\n    it(\"maps providers to environment variable names\", () => {\n      expectTypeOf<\n        typeof Stagehand.providerEnvVarMap\n      >().toExtend<ExpectedProviderEnvVarMap>();\n    });\n  });\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA,oBAA2C;AAC3C,gBAA2B;AAAA,IAE3B,wBAAS,kCAAkC,MAAM;AAC/C,8BAAS,cAAc,MAAM;AAO3B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAwC;AAAA,IAC/D,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,kBAAkB,MAAM;AAG/B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA4C;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,qBAAqB,MAAM;AAMlC,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA+C;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,qBAAqB,MAAM;AAKlC,0BAAG,gDAAgD,MAAM;AACvD,sCAEE,EAAE,SAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/tests/public-api/schema-utils.test.js

@@ -0,0 +1,100 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var Stagehand = __toESM(require("@browserbasehq/stagehand"), 1);
+(0, import_vitest.describe)("Schema Utils public API types", () => {
+  (0, import_vitest.describe)("defaultExtractSchema", () => {
+    (0, import_vitest.it)("infers to the correct type", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("getZodType", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.getZodType
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("isZod3Schema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.isZod3Schema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("isZod4Schema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.isZod4Schema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("jsonSchemaToZod", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.jsonSchemaToZod
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("pageTextSchema", () => {
+    (0, import_vitest.it)("infers to the correct type", () => {
+      (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("toGeminiSchema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.toGeminiSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("toJsonSchema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.toJsonSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("transformSchema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.transformSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("trimTrailingTextNode", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.trimTrailingTextNode
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+  (0, import_vitest.describe)("validateZodSchema", () => {
+    (0, import_vitest.it)("has correct parameter types", () => {
+      (0, import_vitest.expectTypeOf)(
+        Stagehand.validateZodSchema
+      ).parameters.branded.toEqualTypeOf();
+    });
+  });
+});
+//# sourceMappingURL=schema-utils.test.js.map

package/dist/cjs/tests/public-api/schema-utils.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/schema-utils.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\ndescribe(\"Schema Utils public API types\", () => {\n  describe(\"defaultExtractSchema\", () => {\n    type ExpectedInferredType = { extraction: string };\n\n    it(\"infers to the correct type\", () => {\n      expectTypeOf<\n        Stagehand.InferStagehandSchema<typeof Stagehand.defaultExtractSchema>\n      >().toEqualTypeOf<ExpectedInferredType>();\n    });\n  });\n\n  describe(\"getZodType\", () => {\n    type ExpectedGetZodTypeParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.getZodType,\n      ).parameters.branded.toEqualTypeOf<ExpectedGetZodTypeParams>();\n    });\n  });\n\n  describe(\"isZod3Schema\", () => {\n    type ExpectedIsZod3SchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isZod3Schema,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsZod3SchemaParams>();\n    });\n  });\n\n  describe(\"isZod4Schema\", () => {\n    type ExpectedIsZod4SchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.isZod4Schema,\n      ).parameters.branded.toEqualTypeOf<ExpectedIsZod4SchemaParams>();\n    });\n  });\n\n  describe(\"jsonSchemaToZod\", () => {\n    type ExpectedJsonSchemaToZodParams = [Stagehand.JsonSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.jsonSchemaToZod,\n      ).parameters.branded.toEqualTypeOf<ExpectedJsonSchemaToZodParams>();\n    });\n  });\n\n  describe(\"pageTextSchema\", () => {\n    type ExpectedInferredType = { pageText: string };\n\n    it(\"infers to the correct type\", () => {\n      expectTypeOf<\n        Stagehand.InferStagehandSchema<typeof Stagehand.pageTextSchema>\n      >().toEqualTypeOf<ExpectedInferredType>();\n    });\n  });\n\n  describe(\"toGeminiSchema\", () => {\n    type ExpectedToGeminiSchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.toGeminiSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedToGeminiSchemaParams>();\n    });\n  });\n\n  describe(\"toJsonSchema\", () => {\n    type ExpectedToJsonSchemaParams = [Stagehand.StagehandZodSchema];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.toJsonSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedToJsonSchemaParams>();\n    });\n  });\n\n  describe(\"transformSchema\", () => {\n    type ExpectedTransformSchemaParams = [\n      Stagehand.StagehandZodSchema,\n      Array<string | number>,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.transformSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedTransformSchemaParams>();\n    });\n  });\n\n  describe(\"trimTrailingTextNode\", () => {\n    type ExpectedTrimTrailingTextNodeParams = [string | undefined];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.trimTrailingTextNode,\n      ).parameters.branded.toEqualTypeOf<ExpectedTrimTrailingTextNodeParams>();\n    });\n  });\n\n  describe(\"validateZodSchema\", () => {\n    type ExpectedValidateZodSchemaParams = [\n      Stagehand.StagehandZodSchema,\n      unknown,\n    ];\n\n    it(\"has correct parameter types\", () => {\n      expectTypeOf(\n        Stagehand.validateZodSchema,\n      ).parameters.branded.toEqualTypeOf<ExpectedValidateZodSchemaParams>();\n    });\n  });\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA,oBAA2C;AAC3C,gBAA2B;AAAA,IAE3B,wBAAS,iCAAiC,MAAM;AAC9C,8BAAS,wBAAwB,MAAM;AAGrC,0BAAG,8BAA8B,MAAM;AACrC,sCAEE,EAAE,cAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,cAAc,MAAM;AAG3B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAwC;AAAA,IAC/D,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,gBAAgB,MAAM;AAG7B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,gBAAgB,MAAM;AAG7B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,mBAAmB,MAAM;AAGhC,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA6C;AAAA,IACpE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,kBAAkB,MAAM;AAG/B,0BAAG,8BAA8B,MAAM;AACrC,sCAEE,EAAE,cAAoC;AAAA,IAC1C,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,kBAAkB,MAAM;AAG/B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA4C;AAAA,IACnE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,gBAAgB,MAAM;AAG7B,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA0C;AAAA,IACjE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,mBAAmB,MAAM;AAMhC,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA6C;AAAA,IACpE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,wBAAwB,MAAM;AAGrC,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAAkD;AAAA,IACzE,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,qBAAqB,MAAM;AAMlC,0BAAG,+BAA+B,MAAM;AACtC;AAAA,QACE,UAAU;AAAA,MACZ,EAAE,WAAW,QAAQ,cAA+C;AAAA,IACtE,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/tests/public-api/timeout-error-types.test.js

@@ -0,0 +1,103 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var Stagehand = __toESM(require("@browserbasehq/stagehand"), 1);
+(0, import_vitest.describe)("Public timeout error types runtime behavior", () => {
+  (0, import_vitest.describe)("ActTimeoutError", () => {
+    (0, import_vitest.it)("is exported and extends Error", () => {
+      const error = new Stagehand.ActTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Error);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.ActTimeoutError);
+      (0, import_vitest.expect)(error.name).toBe("ActTimeoutError");
+    });
+    (0, import_vitest.it)("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ActTimeoutError(500);
+      (0, import_vitest.expect)(error.message).toContain("500ms");
+    });
+    (0, import_vitest.it)("contains operation name in message", () => {
+      const error = new Stagehand.ActTimeoutError(100);
+      (0, import_vitest.expect)(error.message).toContain("act()");
+    });
+    (0, import_vitest.it)("extends TimeoutError", () => {
+      const error = new Stagehand.ActTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+  (0, import_vitest.describe)("ExtractTimeoutError", () => {
+    (0, import_vitest.it)("is exported and extends Error", () => {
+      const error = new Stagehand.ExtractTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Error);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.ExtractTimeoutError);
+      (0, import_vitest.expect)(error.name).toBe("ExtractTimeoutError");
+    });
+    (0, import_vitest.it)("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ExtractTimeoutError(1e3);
+      (0, import_vitest.expect)(error.message).toContain("1000ms");
+    });
+    (0, import_vitest.it)("contains operation name in message", () => {
+      const error = new Stagehand.ExtractTimeoutError(100);
+      (0, import_vitest.expect)(error.message).toContain("extract()");
+    });
+    (0, import_vitest.it)("extends TimeoutError", () => {
+      const error = new Stagehand.ExtractTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+  (0, import_vitest.describe)("ObserveTimeoutError", () => {
+    (0, import_vitest.it)("is exported and extends Error", () => {
+      const error = new Stagehand.ObserveTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Error);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.ObserveTimeoutError);
+      (0, import_vitest.expect)(error.name).toBe("ObserveTimeoutError");
+    });
+    (0, import_vitest.it)("contains timeout value in milliseconds in message", () => {
+      const error = new Stagehand.ObserveTimeoutError(1500);
+      (0, import_vitest.expect)(error.message).toContain("1500ms");
+    });
+    (0, import_vitest.it)("contains operation name in message", () => {
+      const error = new Stagehand.ObserveTimeoutError(100);
+      (0, import_vitest.expect)(error.message).toContain("observe()");
+    });
+    (0, import_vitest.it)("extends TimeoutError", () => {
+      const error = new Stagehand.ObserveTimeoutError(1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+  });
+  (0, import_vitest.describe)("TimeoutError (base class)", () => {
+    (0, import_vitest.it)("is exported and extends Error", () => {
+      const error = new Stagehand.TimeoutError("custom operation", 2e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Error);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.TimeoutError);
+    });
+    (0, import_vitest.it)("contains operation name and timeout in message", () => {
+      const error = new Stagehand.TimeoutError("custom operation", 2e3);
+      (0, import_vitest.expect)(error.message).toContain("custom operation");
+      (0, import_vitest.expect)(error.message).toContain("2000ms");
+    });
+    (0, import_vitest.it)("extends StagehandError", () => {
+      const error = new Stagehand.TimeoutError("operation", 1e3);
+      (0, import_vitest.expect)(error).toBeInstanceOf(Stagehand.StagehandError);
+    });
+  });
+});
+//# sourceMappingURL=timeout-error-types.test.js.map

package/dist/cjs/tests/public-api/timeout-error-types.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/timeout-error-types.test.ts"],
+  "sourcesContent": ["import { describe, expect, it } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\n\n// ============================================================================\n// Public Timeout Error Types Runtime Tests\n// ============================================================================\n// These tests verify the runtime behavior of exported timeout error types,\n// complementing the type-level tests in public-error-types.test.ts\n\ndescribe(\"Public timeout error types runtime behavior\", () => {\n  describe(\"ActTimeoutError\", () => {\n    it(\"is exported and extends Error\", () => {\n      const error = new Stagehand.ActTimeoutError(1000);\n      expect(error).toBeInstanceOf(Error);\n      expect(error).toBeInstanceOf(Stagehand.ActTimeoutError);\n      expect(error.name).toBe(\"ActTimeoutError\");\n    });\n\n    it(\"contains timeout value in milliseconds in message\", () => {\n      const error = new Stagehand.ActTimeoutError(500);\n      expect(error.message).toContain(\"500ms\");\n    });\n\n    it(\"contains operation name in message\", () => {\n      const error = new Stagehand.ActTimeoutError(100);\n      expect(error.message).toContain(\"act()\");\n    });\n\n    it(\"extends TimeoutError\", () => {\n      const error = new Stagehand.ActTimeoutError(1000);\n      expect(error).toBeInstanceOf(Stagehand.TimeoutError);\n    });\n  });\n\n  describe(\"ExtractTimeoutError\", () => {\n    it(\"is exported and extends Error\", () => {\n      const error = new Stagehand.ExtractTimeoutError(1000);\n      expect(error).toBeInstanceOf(Error);\n      expect(error).toBeInstanceOf(Stagehand.ExtractTimeoutError);\n      expect(error.name).toBe(\"ExtractTimeoutError\");\n    });\n\n    it(\"contains timeout value in milliseconds in message\", () => {\n      const error = new Stagehand.ExtractTimeoutError(1000);\n      expect(error.message).toContain(\"1000ms\");\n    });\n\n    it(\"contains operation name in message\", () => {\n      const error = new Stagehand.ExtractTimeoutError(100);\n      expect(error.message).toContain(\"extract()\");\n    });\n\n    it(\"extends TimeoutError\", () => {\n      const error = new Stagehand.ExtractTimeoutError(1000);\n      expect(error).toBeInstanceOf(Stagehand.TimeoutError);\n    });\n  });\n\n  describe(\"ObserveTimeoutError\", () => {\n    it(\"is exported and extends Error\", () => {\n      const error = new Stagehand.ObserveTimeoutError(1000);\n      expect(error).toBeInstanceOf(Error);\n      expect(error).toBeInstanceOf(Stagehand.ObserveTimeoutError);\n      expect(error.name).toBe(\"ObserveTimeoutError\");\n    });\n\n    it(\"contains timeout value in milliseconds in message\", () => {\n      const error = new Stagehand.ObserveTimeoutError(1500);\n      expect(error.message).toContain(\"1500ms\");\n    });\n\n    it(\"contains operation name in message\", () => {\n      const error = new Stagehand.ObserveTimeoutError(100);\n      expect(error.message).toContain(\"observe()\");\n    });\n\n    it(\"extends TimeoutError\", () => {\n      const error = new Stagehand.ObserveTimeoutError(1000);\n      expect(error).toBeInstanceOf(Stagehand.TimeoutError);\n    });\n  });\n\n  describe(\"TimeoutError (base class)\", () => {\n    it(\"is exported and extends Error\", () => {\n      const error = new Stagehand.TimeoutError(\"custom operation\", 2000);\n      expect(error).toBeInstanceOf(Error);\n      expect(error).toBeInstanceOf(Stagehand.TimeoutError);\n    });\n\n    it(\"contains operation name and timeout in message\", () => {\n      const error = new Stagehand.TimeoutError(\"custom operation\", 2000);\n      expect(error.message).toContain(\"custom operation\");\n      expect(error.message).toContain(\"2000ms\");\n    });\n\n    it(\"extends StagehandError\", () => {\n      const error = new Stagehand.TimeoutError(\"operation\", 1000);\n      expect(error).toBeInstanceOf(Stagehand.StagehandError);\n    });\n  });\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA,oBAAqC;AACrC,gBAA2B;AAAA,IAQ3B,wBAAS,+CAA+C,MAAM;AAC5D,8BAAS,mBAAmB,MAAM;AAChC,0BAAG,iCAAiC,MAAM;AACxC,YAAM,QAAQ,IAAI,UAAU,gBAAgB,GAAI;AAChD,gCAAO,KAAK,EAAE,eAAe,KAAK;AAClC,gCAAO,KAAK,EAAE,eAAe,UAAU,eAAe;AACtD,gCAAO,MAAM,IAAI,EAAE,KAAK,iBAAiB;AAAA,IAC3C,CAAC;AAED,0BAAG,qDAAqD,MAAM;AAC5D,YAAM,QAAQ,IAAI,UAAU,gBAAgB,GAAG;AAC/C,gCAAO,MAAM,OAAO,EAAE,UAAU,OAAO;AAAA,IACzC,CAAC;AAED,0BAAG,sCAAsC,MAAM;AAC7C,YAAM,QAAQ,IAAI,UAAU,gBAAgB,GAAG;AAC/C,gCAAO,MAAM,OAAO,EAAE,UAAU,OAAO;AAAA,IACzC,CAAC;AAED,0BAAG,wBAAwB,MAAM;AAC/B,YAAM,QAAQ,IAAI,UAAU,gBAAgB,GAAI;AAChD,gCAAO,KAAK,EAAE,eAAe,UAAU,YAAY;AAAA,IACrD,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,uBAAuB,MAAM;AACpC,0BAAG,iCAAiC,MAAM;AACxC,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAI;AACpD,gCAAO,KAAK,EAAE,eAAe,KAAK;AAClC,gCAAO,KAAK,EAAE,eAAe,UAAU,mBAAmB;AAC1D,gCAAO,MAAM,IAAI,EAAE,KAAK,qBAAqB;AAAA,IAC/C,CAAC;AAED,0BAAG,qDAAqD,MAAM;AAC5D,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAI;AACpD,gCAAO,MAAM,OAAO,EAAE,UAAU,QAAQ;AAAA,IAC1C,CAAC;AAED,0BAAG,sCAAsC,MAAM;AAC7C,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAG;AACnD,gCAAO,MAAM,OAAO,EAAE,UAAU,WAAW;AAAA,IAC7C,CAAC;AAED,0BAAG,wBAAwB,MAAM;AAC/B,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAI;AACpD,gCAAO,KAAK,EAAE,eAAe,UAAU,YAAY;AAAA,IACrD,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,uBAAuB,MAAM;AACpC,0BAAG,iCAAiC,MAAM;AACxC,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAI;AACpD,gCAAO,KAAK,EAAE,eAAe,KAAK;AAClC,gCAAO,KAAK,EAAE,eAAe,UAAU,mBAAmB;AAC1D,gCAAO,MAAM,IAAI,EAAE,KAAK,qBAAqB;AAAA,IAC/C,CAAC;AAED,0BAAG,qDAAqD,MAAM;AAC5D,YAAM,QAAQ,IAAI,UAAU,oBAAoB,IAAI;AACpD,gCAAO,MAAM,OAAO,EAAE,UAAU,QAAQ;AAAA,IAC1C,CAAC;AAED,0BAAG,sCAAsC,MAAM;AAC7C,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAG;AACnD,gCAAO,MAAM,OAAO,EAAE,UAAU,WAAW;AAAA,IAC7C,CAAC;AAED,0BAAG,wBAAwB,MAAM;AAC/B,YAAM,QAAQ,IAAI,UAAU,oBAAoB,GAAI;AACpD,gCAAO,KAAK,EAAE,eAAe,UAAU,YAAY;AAAA,IACrD,CAAC;AAAA,EACH,CAAC;AAED,8BAAS,6BAA6B,MAAM;AAC1C,0BAAG,iCAAiC,MAAM;AACxC,YAAM,QAAQ,IAAI,UAAU,aAAa,oBAAoB,GAAI;AACjE,gCAAO,KAAK,EAAE,eAAe,KAAK;AAClC,gCAAO,KAAK,EAAE,eAAe,UAAU,YAAY;AAAA,IACrD,CAAC;AAED,0BAAG,kDAAkD,MAAM;AACzD,YAAM,QAAQ,IAAI,UAAU,aAAa,oBAAoB,GAAI;AACjE,gCAAO,MAAM,OAAO,EAAE,UAAU,kBAAkB;AAClD,gCAAO,MAAM,OAAO,EAAE,UAAU,QAAQ;AAAA,IAC1C,CAAC;AAED,0BAAG,0BAA0B,MAAM;AACjC,YAAM,QAAQ,IAAI,UAAU,aAAa,aAAa,GAAI;AAC1D,gCAAO,KAAK,EAAE,eAAe,UAAU,cAAc;AAAA,IACvD,CAAC;AAAA,EACH,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/cjs/tests/public-api/tool-type-export.test.js

@@ -0,0 +1,47 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var Stagehand = __toESM(require("@browserbasehq/stagehand"), 1);
+var import_zod = require("zod");
+(0, import_vitest.describe)("Tool exports from AI SDK", () => {
+  (0, import_vitest.it)("exports Tool type that matches AI SDK Tool type", () => {
+    (0, import_vitest.expectTypeOf)().toEqualTypeOf();
+  });
+  (0, import_vitest.it)("exports tool function", () => {
+    (0, import_vitest.expect)(typeof Stagehand.tool).toBe("function");
+  });
+  (0, import_vitest.it)("tool function can be used to define custom tools", () => {
+    const customTool = Stagehand.tool({
+      description: "A test tool",
+      inputSchema: import_zod.z.object({
+        input: import_zod.z.string()
+      }),
+      execute: async ({ input }) => {
+        return { result: `Processed: ${input}` };
+      }
+    });
+    (0, import_vitest.expect)(customTool).toBeDefined();
+    (0, import_vitest.expect)(customTool.description).toBe("A test tool");
+  });
+});
+//# sourceMappingURL=tool-type-export.test.js.map

package/dist/cjs/tests/public-api/tool-type-export.test.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../tests/public-api/tool-type-export.test.ts"],
+  "sourcesContent": ["import { describe, expectTypeOf, it, expect } from \"vitest\";\nimport * as Stagehand from \"@browserbasehq/stagehand\";\nimport { type Tool } from \"ai\";\nimport { z } from \"zod\";\n\n/**\n * Test to verify tool-related exports from Stagehand.\n * Users should be able to create custom tools using the exported `tool` function\n * without needing to install the ai package directly.\n */\ndescribe(\"Tool exports from AI SDK\", () => {\n  it(\"exports Tool type that matches AI SDK Tool type\", () => {\n    expectTypeOf<Stagehand.Tool>().toEqualTypeOf<Tool>();\n  });\n\n  it(\"exports tool function\", () => {\n    expect(typeof Stagehand.tool).toBe(\"function\");\n  });\n\n  it(\"tool function can be used to define custom tools\", () => {\n    const customTool = Stagehand.tool({\n      description: \"A test tool\",\n      inputSchema: z.object({\n        input: z.string(),\n      }),\n      execute: async ({ input }) => {\n        return { result: `Processed: ${input}` };\n      },\n    });\n\n    expect(customTool).toBeDefined();\n    expect(customTool.description).toBe(\"A test tool\");\n  });\n});\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA,oBAAmD;AACnD,gBAA2B;AAE3B,iBAAkB;AAAA,IAOlB,wBAAS,4BAA4B,MAAM;AACzC,wBAAG,mDAAmD,MAAM;AAC1D,oCAA6B,EAAE,cAAoB;AAAA,EACrD,CAAC;AAED,wBAAG,yBAAyB,MAAM;AAChC,8BAAO,OAAO,UAAU,IAAI,EAAE,KAAK,UAAU;AAAA,EAC/C,CAAC;AAED,wBAAG,oDAAoD,MAAM;AAC3D,UAAM,aAAa,UAAU,KAAK;AAAA,MAChC,aAAa;AAAA,MACb,aAAa,aAAE,OAAO;AAAA,QACpB,OAAO,aAAE,OAAO;AAAA,MAClB,CAAC;AAAA,MACD,SAAS,OAAO,EAAE,MAAM,MAAM;AAC5B,eAAO,EAAE,QAAQ,cAAc,KAAK,GAAG;AAAA,MACzC;AAAA,IACF,CAAC;AAED,8BAAO,UAAU,EAAE,YAAY;AAC/B,8BAAO,WAAW,WAAW,EAAE,KAAK,aAAa;AAAA,EACnD,CAAC;AACH,CAAC;",
+  "names": []
+}