@dev-blinq/bvt-playwright-js 1.0.0-dev.2 → 1.0.0-dev.3

package/index.mjs

@@ -276,6 +276,20 @@ var TestDataApi = class {
 		this.options.onChange?.();
 	}
 	/**
+	* Shorthand for {@link setRuntime}. Saves a value to the current session's
+	* runtime scope, resolvable as `{{key}}` in subsequent steps.
+	*/
+	async set(key, value, opts = {}) {
+		return this.setRuntime(key, value, opts);
+	}
+	/**
+	* Shorthand for {@link getRuntime}. Reads a value from the current session's
+	* runtime scope. Returns `null` if no entry exists for `key`.
+	*/
+	async get(key) {
+		return this.getRuntime(key);
+	}
+	/**
 	* Read a runtime value previously saved via setRuntime or an extract step.
 	*
 	* Returns `null` if no entry exists for `key` in the current runtime scope.
@@ -6014,6 +6028,14 @@ const CommandSchema = discriminatedUnion("type", [
 		data: unknown().optional(),
 		config: CommandConfigSchema.optional()
 	}).strict(),
+	object({
+		_id: EntityIdSchema,
+		type: literal$1("custom.code"),
+		runtime: literal$1("secure-exec-v1").default("secure-exec-v1"),
+		language: literal$1("javascript").default("javascript"),
+		code: string().min(1).max(5e4),
+		config: CommandConfigSchema.optional()
+	}).strict(),
 	object({
 		_id: EntityIdSchema,
 		type: literal$1("api.action"),
@@ -6032,7 +6054,7 @@ const CommandSchema = discriminatedUnion("type", [
 //#region ../../core/schemas/src/scenario/scenario.schema.ts
 const TagSchema = object({
 	_id: EntityIdSchema,
-	name: string().min(1).max(100),
+	name: string().min(1).max(50).regex(/^[a-z0-9_-]+$/, "Tag name can only contain lowercase letters, numbers, hyphens, and underscores"),
 	projectId: EntityIdSchema
 }).strict();
 const RecorderModes = [
@@ -6437,14 +6459,14 @@ const BrowserObserverStateKSchema = union([_enum([
 
 //#endregion
 //#region ../../node_modules/xstate/dev/dist/xstate-dev.esm.js
-function getGlobal() {
+function getGlobal$1() {
 	if (typeof globalThis !== "undefined") return globalThis;
 	if (typeof self !== "undefined") return self;
 	if (typeof window !== "undefined") return window;
 	if (typeof global !== "undefined") return global;
 }
 function getDevTools() {
-	const w = getGlobal();
+	const w = getGlobal$1();
 	if (w.__xstate__) return w.__xstate__;
 }
 const devToolsAdapter = (service) => {
@@ -9868,16 +9890,24 @@ const AiChatPageContextSchema = object({
 	domSnapshot: string().min(1).optional(),
 	screenshotBase64: string().min(1).optional()
 }).strict();
-const AvailableModelSchema = object({
-	provider: string(),
-	model: string(),
-	name: string().optional()
-});
 const ValidationComplexitySchema = _enum([
 	"simple",
 	"moderate",
 	"complex"
 ]);
+/**
+* Discriminator for the observe-act loop's per-step semantic intent:
+*   - "act":    the step performs an action that mutates page state
+*               (click, fill, navigate, etc.) and is verified by the
+*               attached predicate.
+*   - "assert": the step verifies a condition about the current page —
+*               the predicate IS the verification and no action runs.
+*
+* Authoritative source for the enum. Re-exported via `@blinq/schemas`;
+* client + worker MUST import this rather than redefining the literal
+* union (see feedback_no_type_duplication.md).
+*/
+const AiChatStepKindSchema = _enum(["act", "assert"]);
 const AiChatValidationResultSchema = object({
 	valid: boolean(),
 	complexity: ValidationComplexitySchema,
@@ -9984,8 +10014,6 @@ const AiChatRequestSchema = object({
 	messages: array(record(string(), unknown())).optional(),
 	pageContext: AiChatPageContextSchema.optional(),
 	workerUrl: url().optional(),
-	provider: string().optional(),
-	model: string().optional(),
 	maxExecutionRetries: number().int().nonnegative().default(5),
 	maxSuccessfulStepsPerRun: number().int().positive().default(8).optional(),
 	maxSemanticActionsPerAiStep: number().int().positive().default(DEFAULT_MAX_SEMANTIC_ACTIONS_PER_AI_STEP),
@@ -10075,14 +10103,16 @@ const AiChatExecutionCompleteEventSchema = object({
 	code: string().min(1),
 	accumulatedCode: string().min(1).optional(),
 	accumulatedCodeSegments: array(AiCodeSegmentSchema).min(1).optional(),
-	execution: ExecutionResultSchema
+	execution: ExecutionResultSchema,
+	stepKind: AiChatStepKindSchema.optional()
 }).strict();
 const AiChatWorkerToolCallEventSchema = object({
 	type: literal$1("worker-tool-call"),
 	callId: string().min(1),
 	toolName: AiChatToolNameSchema,
 	args: unknown(),
-	runId: string().optional()
+	runId: string().optional(),
+	trace: record(string(), string()).optional()
 }).strict();
 const PlanSummaryCommittedStepSchema = object({
 	stepId: string().min(1),
@@ -10090,7 +10120,8 @@ const PlanSummaryCommittedStepSchema = object({
 	code: string().min(1),
 	success: boolean(),
 	failureCode: string().min(1).optional(),
-	codeSegments: array(AiCodeSegmentSchema).min(1).optional()
+	codeSegments: array(AiCodeSegmentSchema).min(1).optional(),
+	stepKind: AiChatStepKindSchema.optional()
 }).strict();
 const AiChatPlanSummaryStatusSchema = _enum([
 	"complete",
@@ -10124,6 +10155,20 @@ const AiChatPlanSummaryEventSchema = object({
 	type: literal$1("plan-summary"),
 	summary: AiChatPlanSummarySchema
 }).strict();
+const AiChatHandoffUnverifiableSchema = object({
+	intent: string().min(1),
+	blocker: _enum([
+		"missing-data",
+		"runtime-arithmetic",
+		"multi-element-ambiguity",
+		"analyzer-rejected-3x",
+		"other"
+	])
+}).strict();
+const AiChatHandoffEventSchema = object({
+	type: literal$1("handoff"),
+	unverifiable: AiChatHandoffUnverifiableSchema
+}).strict();
 const AiChatEventSchema = discriminatedUnion("type", [
 	AiChatThinkingEventSchema,
 	AiChatExplorationEventSchema,
@@ -10131,7 +10176,8 @@ const AiChatEventSchema = discriminatedUnion("type", [
 	AiChatCompleteEventSchema,
 	AiChatExecutionCompleteEventSchema,
 	AiChatWorkerToolCallEventSchema,
-	AiChatPlanSummaryEventSchema
+	AiChatPlanSummaryEventSchema,
+	AiChatHandoffEventSchema
 ]);
 const AiChatDataThinkingPartSchema = object({
 	type: literal$1("data-thinking"),
@@ -10148,7 +10194,8 @@ const AiChatDataExecutionStatusPartSchema = object({
 	checkpoints: array(CheckpointSchema).optional().default([]),
 	error: string().optional(),
 	userMessage: string().optional(),
-	screenshotAfter: string().optional()
+	screenshotAfter: string().optional(),
+	stepKind: AiChatStepKindSchema.optional()
 });
 /**
 * Wire-level mode values emitted by ai-server in `complete` events. Enumerated
@@ -10198,6 +10245,10 @@ const AiChatDataGeneratedCodePartSchema = object({
 	code: string(),
 	validation: AiChatValidationResultSchema
 });
+const AiChatDataHandoffPartSchema = object({
+	type: literal$1("data-handoff"),
+	unverifiable: AiChatHandoffUnverifiableSchema
+});
 const AiChatDataPartSchema = discriminatedUnion("type", [
 	AiChatDataThinkingPartSchema,
 	AiChatDataExecutionStatusPartSchema,
@@ -10205,7 +10256,8 @@ const AiChatDataPartSchema = discriminatedUnion("type", [
 	AiChatDataErrorPartSchema,
 	AiChatDataPlanSummaryPartSchema,
 	AiChatDataExplorationPartSchema,
-	AiChatDataGeneratedCodePartSchema
+	AiChatDataGeneratedCodePartSchema,
+	AiChatDataHandoffPartSchema
 ]);
 /** Schema for multi-turn continuation prompts. pageContext is REQUIRED (fixes bug 4 structurally). */
 const ContinuationPromptInputSchema = object({
@@ -10392,6 +10444,10 @@ const aiChatMachine = setup({
 				contractViolation: {
 					tags: ["invalid-contract", "has-code"],
 					on: {
+						SAVE: {
+							target: "idle",
+							actions: "clearPending"
+						},
 						RETRY: {
 							target: "streaming",
 							actions: "captureSubmission"
@@ -10570,7 +10626,7 @@ const UrlPredicateKindSchema = _enum([
 	"changed-from-baseline"
 ]);
 const POSTCONDITION_GENERATION_MAX_NESTED_DEPTH = 1;
-const PostconditionStatusSchema = number().optional().describe("Optional HTTP status code. Use an integer between 100 and 599.");
+const PostconditionStatusSchema = number().nullable().describe("HTTP status code (null when absent). Use an integer between 100 and 599.");
 function validateUrlPredicate(predicate, ctx) {
 	if (!predicate) return;
 	const hasValue = typeof predicate.value !== "undefined";
@@ -10631,22 +10687,27 @@ const ChangedFromBaselineUrlPredicateGenerationPayloadSchema = object({}).strict
 const PostconditionGenerationRouteSchema = object({ kind: PostconditionKindSchema }).strict();
 const PostconditionGenerationLeafRouteSchema = object({ kind: PostconditionLeafKindSchema }).strict();
 const CommonLeafFields = {
-	negate: boolean().optional(),
-	timeoutMs: number().int().positive().optional()
+	negate: boolean().nullable(),
+	timeoutMs: number().int().positive().nullable()
 };
-const UrlPostconditionGenerationPayloadSchema = object({ predicate: UrlPredicateGenerationRouteSchema }).strict();
+const UrlPostconditionGenerationPayloadSchema = object({
+	predicate: UrlPredicateGenerationRouteSchema,
+	...CommonLeafFields
+}).strict();
 const DomPostconditionGenerationPayloadSchema = object({
 	selector: SelectorString,
-	state: DomPostconditionStateSchema
+	state: DomPostconditionStateSchema,
+	...CommonLeafFields
 }).strict();
 const TextPostconditionGenerationPayloadSchema = object({
 	text: string().min(1),
-	match: TextPostconditionMatchSchema
+	match: TextPostconditionMatchSchema,
+	...CommonLeafFields
 }).strict();
 const DomCountPostconditionGenerationPayloadSchema = object({
 	selector: SelectorString,
 	n: number().int().min(0),
-	op: DomCountOpSchema.optional(),
+	op: DomCountOpSchema.nullable(),
 	...CommonLeafFields
 }).strict();
 const ValuePostconditionGenerationPayloadSchema = object({
@@ -10658,7 +10719,7 @@ const ValuePostconditionGenerationPayloadSchema = object({
 const AttributePostconditionGenerationPayloadSchema = object({
 	selector: SelectorString,
 	name: string().min(1),
-	value: string().optional(),
+	value: string().nullable(),
 	...CommonLeafFields
 }).strict();
 const TitlePostconditionGenerationPayloadSchema = object({
@@ -10668,7 +10729,8 @@ const TitlePostconditionGenerationPayloadSchema = object({
 }).strict();
 const NetworkPostconditionGenerationPayloadSchema = object({
 	predicate: UrlPredicateGenerationRouteSchema,
-	status: PostconditionStatusSchema
+	status: PostconditionStatusSchema,
+	...CommonLeafFields
 }).strict().superRefine((value, ctx) => {
 	if (typeof value.status === "number" && !Number.isInteger(value.status)) ctx.addIssue({
 		code: "custom",
@@ -11014,10 +11076,14 @@ function containsLegacyCode(node) {
 const PostconditionNodeGenerationSchema = PostconditionCanonicalSchema.refine((node) => !containsLegacyCode(node), { message: "legacy-code leaf is read-only and must not appear in generation output." });
 const ResolvedAllOfPostconditionGenerationPayloadSchema = object({ conditions: array(PostconditionLeafCanonicalSchema).min(1) }).strict();
 const ResolvedAnyOfPostconditionGenerationPayloadSchema = object({ conditions: array(PostconditionLeafCanonicalSchema).min(1) }).strict();
-const ResolvedUrlPostconditionGenerationPayloadSchema = object({ predicate: UrlPredicateCanonicalSchema }).strict();
+const ResolvedUrlPostconditionGenerationPayloadSchema = object({
+	predicate: UrlPredicateCanonicalSchema,
+	...CommonLeafFields
+}).strict();
 const ResolvedNetworkPostconditionGenerationPayloadSchema = object({
 	predicate: UrlPredicateCanonicalSchema,
-	status: PostconditionStatusSchema
+	status: PostconditionStatusSchema,
+	...CommonLeafFields
 }).strict().superRefine((value, ctx) => {
 	if (typeof value.status === "number" && !Number.isInteger(value.status)) ctx.addIssue({
 		code: "custom",
@@ -11070,6 +11136,28 @@ const WorkerClientToolExecuteResponseSchema = object({ result: unknown() }).stri
 
 //#endregion
 //#region ../../core/schemas/src/ai-chat/observe-act-generation.schema.ts
+/**
+* Walk a canonical PostconditionCanonical node and return true if any leaf is a
+* URL or network postcondition whose inner predicate kind is
+* "changed-from-baseline".
+*
+* Used by the kind="assert" guardrail on ResolvedStepBase: `changed-from-baseline`
+* asserts that a navigation occurred AS A CONSEQUENCE of an action, which is
+* semantically invalid on a kind="assert" step (which has no action).
+*
+* Scope: file-local helper. Not exported from the package barrel — blast radius
+* stays inside this file, and exhaustive coverage lives in
+* observe-act-generation.schema.test.ts.
+*/
+function postconditionReferencesChangedFromBaseline(node) {
+	switch (node.kind) {
+		case "url":
+		case "network": return node.predicate.kind === "changed-from-baseline";
+		case "all-of":
+		case "any-of": return node.conditions.some(postconditionReferencesChangedFromBaseline);
+		default: return false;
+	}
+}
 const ObserveActGenerationCheckpointSchema = object({
 	label: string().min(1),
 	timestampMs: number().nonnegative()
@@ -11144,85 +11232,97 @@ const ObserveActGenerationInputSchema = object({
 	pinnedElement: ObserveActGenerationPinnedElementSchema.optional(),
 	availableTestData: array(ListAvailableTestDataEntrySchema).readonly().optional()
 }).strict();
-const ObserveActGenerationTypeSchema = _enum([
-	"step",
-	"assertion",
-	"complete"
-]);
+const ObserveActGenerationTypeSchema = _enum(["step", "complete"]);
 const ObserveActGenerationRouteSchema = object({ type: ObserveActGenerationTypeSchema }).strict();
-const ObserveActGenerationStepShellPayloadSchema = object({
+const UnverifiableSchema = object({
+	intent: string().min(1),
+	blocker: _enum([
+		"missing-data",
+		"runtime-arithmetic",
+		"multi-element-ambiguity",
+		"analyzer-rejected-3x",
+		"other"
+	])
+}).strict();
+const StepShellBase = object({
 	stepGoal: string().min(1),
-	actionCode: string().min(1),
-	postcondition: PostconditionGenerationRouteSchema
+	kind: _enum(["act", "assert"]),
+	actionCode: string().min(1).nullable(),
+	postCondition: PostconditionGenerationRouteSchema
 }).strict();
-const ObserveActGenerationResolvedStepPayloadSchema = object({
+const ObserveActGenerationStepShellPayloadSchema = StepShellBase.superRefine((data, ctx) => {
+	if (data.kind === "act" && (data.actionCode === null || data.actionCode.length === 0)) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "kind=act requires actionCode",
+		path: ["actionCode"]
+	});
+	if (data.kind === "assert" && data.actionCode !== null) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "kind=assert must emit actionCode: null",
+		path: ["actionCode"]
+	});
+});
+const ResolvedStepBase = object({
 	stepGoal: string().min(1),
-	actionCode: string().min(1),
-	postcondition: PostconditionCanonicalSchema
+	kind: _enum(["act", "assert"]),
+	actionCode: string().min(1).nullable(),
+	postCondition: PostconditionCanonicalSchema
+}).strict();
+const ObserveActGenerationResolvedStepPayloadSchema = ResolvedStepBase.superRefine((data, ctx) => {
+	if (data.kind === "act" && (data.actionCode === null || data.actionCode.length === 0)) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "kind=act requires actionCode",
+		path: ["actionCode"]
+	});
+	if (data.kind === "assert" && data.actionCode !== null) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "kind=assert must emit actionCode: null",
+		path: ["actionCode"]
+	});
+	if (data.kind === "assert" && postconditionReferencesChangedFromBaseline(data.postCondition)) ctx.addIssue({
+		code: ZodIssueCode.custom,
+		message: "url/network predicate \"changed-from-baseline\" is not valid on kind=\"assert\" steps; pick a concrete url leaf (equals/contains/path-contains/matches-regex) or a different leaf.",
+		path: ["postCondition"]
+	});
+});
+const ObserveActGenerationCompletePayloadSchema = object({
+	reason: string().min(1),
+	unverifiable: UnverifiableSchema.nullable()
 }).strict();
+/** @deprecated The assertion route is removed (PR #341). */
 const ObserveActGenerationAssertionPayloadSchema = object({
 	assertionGoal: string().min(1),
 	assertionCode: string().min(1)
 }).strict();
-const ObserveActGenerationCompletePayloadSchema = object({ reason: string().min(1) }).strict();
 const ObserveActGenerationResolvedGroupPostconditionPayloadSchema = object({ conditions: array(PostconditionLeafCanonicalSchema).min(1) }).strict();
 const ObserveActGenerationCanonicalSchema = object({
 	type: ObserveActGenerationTypeSchema,
 	step: ObserveActGenerationResolvedStepPayloadSchema.optional(),
-	assertion: ObserveActGenerationAssertionPayloadSchema.optional(),
 	complete: ObserveActGenerationCompletePayloadSchema.optional()
 }).strict().superRefine((value, ctx) => {
 	if (value.type === "step") {
 		if (!value.step) ctx.addIssue({
-			code: "custom",
+			code: ZodIssueCode.custom,
 			path: ["step"],
 			message: "step is required when type is 'step'."
 		});
-		if (value.assertion) ctx.addIssue({
-			code: "custom",
-			path: ["assertion"],
-			message: "assertion is not allowed when type is 'step'."
-		});
 		if (value.complete) ctx.addIssue({
-			code: "custom",
+			code: ZodIssueCode.custom,
 			path: ["complete"],
 			message: "complete is not allowed when type is 'step'."
 		});
-		return;
-	}
-	if (value.type === "assertion") {
-		if (!value.assertion) ctx.addIssue({
-			code: "custom",
-			path: ["assertion"],
-			message: "assertion is required when type is 'assertion'."
+	} else if (value.type === "complete") {
+		if (!value.complete) ctx.addIssue({
+			code: ZodIssueCode.custom,
+			path: ["complete"],
+			message: "complete is required when type is 'complete'."
 		});
 		if (value.step) ctx.addIssue({
-			code: "custom",
+			code: ZodIssueCode.custom,
 			path: ["step"],
-			message: "step is not allowed when type is 'assertion'."
-		});
-		if (value.complete) ctx.addIssue({
-			code: "custom",
-			path: ["complete"],
-			message: "complete is not allowed when type is 'assertion'."
+			message: "step is not allowed when type is 'complete'."
 		});
-		return;
 	}
-	if (!value.complete) ctx.addIssue({
-		code: "custom",
-		path: ["complete"],
-		message: "complete is required when type is 'complete'."
-	});
-	if (value.step) ctx.addIssue({
-		code: "custom",
-		path: ["step"],
-		message: "step is not allowed when type is 'complete'."
-	});
-	if (value.assertion) ctx.addIssue({
-		code: "custom",
-		path: ["assertion"],
-		message: "assertion is not allowed when type is 'complete'."
-	});
 });
 
 //#endregion
@@ -11260,7 +11360,8 @@ const FEATURE_FLAG_KEYS = [
 	"NewFirstUserFlow_DemoPage",
 	"EnvReachabilityCheck",
 	"SlackIntegration",
-	"ExecutionNotifications"
+	"ExecutionNotifications",
+	"ExecutionEditorModeSwitching"
 ];
 const FeatureFlagKeySchema = _enum(FEATURE_FLAG_KEYS);
 const FeatureFlagSchema = object({
@@ -17842,162 +17943,1935 @@ async function validatePlaywrightCode(code) {
 }
 
 //#endregion
-//#region ../../core/bvt-agent/src/agent/playwright-runner.ts
+//#region ../../node_modules/@opentelemetry/api/build/esm/version.js
+const VERSION = "1.9.1";
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/internal/semver.js
+const re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
 /**
-* Blocked methods are dangerous in a sandbox context (code execution, request
-* interception, browser/context escape, etc.).  Everything else discovered at
-* runtime on the real Playwright objects is automatically allowed, so new
-* Playwright API additions work without manual updates.
+* Create a function to test an API version to see if it is compatible with the provided ownVersion.
+*
+* The returned function has the following semantics:
+* - Exact match is always compatible
+* - Major versions must match exactly
+*    - 1.x package cannot use global 2.x package
+*    - 2.x package cannot use global 1.x package
+* - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+*    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+*    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+* - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+* - Patch and build tag differences are not considered at this time
+*
+* @param ownVersion version which should be checked against
 */
-const BLOCKED_PAGE_METHODS = new Set([
-	"evaluate",
-	"evaluateHandle",
-	"$eval",
-	"$$eval",
-	"addScriptTag",
-	"addStyleTag",
-	"exposeFunction",
-	"exposeBinding",
-	"addInitScript",
-	"route",
-	"unroute",
-	"routeFromHAR",
-	"unrouteAll",
-	"context",
-	"close",
-	"bringToFront",
-	"setContent",
-	"setExtraHTTPHeaders",
-	"setInputFiles",
-	"pdf",
-	"screenshot",
-	"video",
-	"on",
-	"off",
-	"once",
-	"emit",
-	"removeListener",
-	"removeAllListeners",
-	"addListener",
-	"setMaxListeners",
-	"waitForEvent",
-	"workers",
-	"frames",
-	"mainFrame",
-	"opener"
-]);
-const BLOCKED_LOCATOR_METHODS = new Set([
-	"evaluate",
-	"evaluateHandle",
-	"evaluateAll",
-	"on",
-	"off",
-	"once",
-	"emit",
-	"removeListener",
-	"removeAllListeners",
-	"addListener",
-	"setMaxListeners",
-	"setInputFiles",
-	"screenshot"
-]);
+function _makeCompatibilityCheck(ownVersion) {
+	const acceptedVersions = new Set([ownVersion]);
+	const rejectedVersions = /* @__PURE__ */ new Set();
+	const myVersionMatch = ownVersion.match(re);
+	if (!myVersionMatch) return () => false;
+	const ownVersionParsed = {
+		major: +myVersionMatch[1],
+		minor: +myVersionMatch[2],
+		patch: +myVersionMatch[3],
+		prerelease: myVersionMatch[4]
+	};
+	if (ownVersionParsed.prerelease != null) return function isExactmatch(globalVersion) {
+		return globalVersion === ownVersion;
+	};
+	function _reject(v) {
+		rejectedVersions.add(v);
+		return false;
+	}
+	function _accept(v) {
+		acceptedVersions.add(v);
+		return true;
+	}
+	return function isCompatible(globalVersion) {
+		if (acceptedVersions.has(globalVersion)) return true;
+		if (rejectedVersions.has(globalVersion)) return false;
+		const globalVersionMatch = globalVersion.match(re);
+		if (!globalVersionMatch) return _reject(globalVersion);
+		const globalVersionParsed = {
+			major: +globalVersionMatch[1],
+			minor: +globalVersionMatch[2],
+			patch: +globalVersionMatch[3],
+			prerelease: globalVersionMatch[4]
+		};
+		if (globalVersionParsed.prerelease != null) return _reject(globalVersion);
+		if (ownVersionParsed.major !== globalVersionParsed.major) return _reject(globalVersion);
+		if (ownVersionParsed.major === 0) {
+			if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) return _accept(globalVersion);
+			return _reject(globalVersion);
+		}
+		if (ownVersionParsed.minor <= globalVersionParsed.minor) return _accept(globalVersion);
+		return _reject(globalVersion);
+	};
+}
 /**
-* Walk the prototype chain and collect every function-valued own-property.
-* Uses property descriptors to avoid triggering getters/accessors (e.g.
-* Playwright's `keyboard`, `mouse` accessors) during introspection.
+* Test an API version to see if it is compatible with this API.
+*
+* - Exact match is always compatible
+* - Major versions must match exactly
+*    - 1.x package cannot use global 2.x package
+*    - 2.x package cannot use global 1.x package
+* - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API
+*    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects
+*    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3
+* - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor
+* - Patch and build tag differences are not considered at this time
+*
+* @param version version of the API requesting an instance of the global API
 */
-function extractMethods(obj) {
-	const methods = /* @__PURE__ */ new Set();
-	let current = obj;
-	while (current && current !== Object.prototype) {
-		for (const key of Object.getOwnPropertyNames(current)) {
-			const descriptor = Object.getOwnPropertyDescriptor(current, key);
-			if (key !== "constructor" && descriptor && typeof descriptor.value === "function") methods.add(key);
-		}
-		current = Object.getPrototypeOf(current);
+const isCompatible = _makeCompatibilityCheck(VERSION);
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+const major = VERSION.split(".")[0];
+const GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(`opentelemetry.js.api.${major}`);
+const _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+function registerGlobal(type, instance, diag, allowOverride = false) {
+	var _a;
+	const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : { version: VERSION };
+	if (!allowOverride && api[type]) {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+		diag.error(err.stack || err.message);
+		return false;
 	}
-	return [...methods];
+	if (api.version !== VERSION) {
+		const err = /* @__PURE__ */ new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+		diag.error(err.stack || err.message);
+		return false;
+	}
+	api[type] = instance;
+	diag.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+	return true;
 }
-const HOST_HELPER_METHODS = [
-	"getPreferredInteractiveTargetSelector",
-	"activatePreferredInteractiveTarget",
-	"activateWithRecovery"
-];
-const FALLBACK_PAGE_METHODS = [
-	"getByAltText",
-	"getByDisplayValue",
-	"getByLabel",
-	"getByPlaceholder",
-	"getByRole",
-	"getByTestId",
-	"getByText",
-	"getByTitle",
-	"goto",
-	"reload",
-	"goBack",
-	"goForward",
-	"locator",
-	"title",
-	"url",
-	"waitForSelector",
-	"waitForTimeout",
-	"waitForURL",
-	"waitForLoadState"
-];
-const FALLBACK_LOCATOR_METHODS = [
-	"allTextContents",
-	"and",
-	"blur",
-	"check",
-	"clear",
-	"click",
-	"count",
-	"fill",
-	"filter",
-	"first",
-	"focus",
-	"getAttribute",
-	"getByAltText",
-	"getByDisplayValue",
-	"getByLabel",
-	"getByPlaceholder",
-	"getByRole",
-	"getByTestId",
-	"getByText",
-	"getByTitle",
-	"hover",
-	"innerText",
-	"inputValue",
-	"isChecked",
-	"isDisabled",
-	"isEnabled",
-	"isHidden",
-	"isVisible",
-	"last",
-	"locator",
-	"nth",
-	"or",
-	"press",
-	"scrollIntoViewIfNeeded",
-	"selectOption",
-	"textContent",
-	"type",
-	"uncheck",
-	"waitFor"
-];
-function buildAllowedMethods(obj, blocked, fallback) {
-	let all = extractMethods(obj);
-	if (all.length === 0) all = fallback;
-	const methods = all.filter((m) => !blocked.has(m));
-	return {
-		methods,
-		methodSet: new Set(methods)
-	};
+function getGlobal(type) {
+	var _a, _b;
+	const globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;
+	if (!globalVersion || !isCompatible(globalVersion)) return;
+	return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
 }
-const HELPER_METHOD_SET = new Set(HOST_HELPER_METHODS);
-const BRIDGE_ERROR_PREFIX = "[playwright-bridge]";
-const RECOVERY_LOCATOR_OPERATION_TIMEOUT_MS = 2e3;
-function recoveryLocatorOptions(extra) {
+function unregisterGlobal(type, diag) {
+	diag.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+	const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+	if (api) delete api[type];
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+/**
+* Component Logger which is meant to be used as part of any component which
+* will add automatically additional namespace in front of the log message.
+* It will then forward all message to global diag logger
+* @example
+* const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });
+* cLogger.debug('test');
+* // @opentelemetry/instrumentation-http test
+*/
+var DiagComponentLogger = class {
+	constructor(props) {
+		this._namespace = props.namespace || "DiagComponentLogger";
+	}
+	debug(...args) {
+		return logProxy("debug", this._namespace, args);
+	}
+	error(...args) {
+		return logProxy("error", this._namespace, args);
+	}
+	info(...args) {
+		return logProxy("info", this._namespace, args);
+	}
+	warn(...args) {
+		return logProxy("warn", this._namespace, args);
+	}
+	verbose(...args) {
+		return logProxy("verbose", this._namespace, args);
+	}
+};
+function logProxy(funcName, namespace, args) {
+	const logger = getGlobal("diag");
+	if (!logger) return;
+	return logger[funcName](namespace, ...args);
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/diag/types.js
+/**
+* Defines the available internal logging levels for the diagnostic logger, the numeric values
+* of the levels are defined to match the original values from the initial LogLevel to avoid
+* compatibility/migration issues for any implementation that assume the numeric ordering.
+*/
+var DiagLogLevel;
+(function(DiagLogLevel) {
+	/** Diagnostic Logging level setting to disable all logging (except and forced logs) */
+	DiagLogLevel[DiagLogLevel["NONE"] = 0] = "NONE";
+	/** Identifies an error scenario */
+	DiagLogLevel[DiagLogLevel["ERROR"] = 30] = "ERROR";
+	/** Identifies a warning scenario */
+	DiagLogLevel[DiagLogLevel["WARN"] = 50] = "WARN";
+	/** General informational log message */
+	DiagLogLevel[DiagLogLevel["INFO"] = 60] = "INFO";
+	/** General debug log message */
+	DiagLogLevel[DiagLogLevel["DEBUG"] = 70] = "DEBUG";
+	/**
+	* Detailed trace level logging should only be used for development, should only be set
+	* in a development environment.
+	*/
+	DiagLogLevel[DiagLogLevel["VERBOSE"] = 80] = "VERBOSE";
+	/** Used to set the logging level to include all logging */
+	DiagLogLevel[DiagLogLevel["ALL"] = 9999] = "ALL";
+})(DiagLogLevel || (DiagLogLevel = {}));
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+function createLogLevelDiagLogger(maxLevel, logger) {
+	if (maxLevel < DiagLogLevel.NONE) maxLevel = DiagLogLevel.NONE;
+	else if (maxLevel > DiagLogLevel.ALL) maxLevel = DiagLogLevel.ALL;
+	logger = logger || {};
+	function _filterFunc(funcName, theLevel) {
+		const theFunc = logger[funcName];
+		if (typeof theFunc === "function" && maxLevel >= theLevel) return theFunc.bind(logger);
+		return function() {};
+	}
+	return {
+		error: _filterFunc("error", DiagLogLevel.ERROR),
+		warn: _filterFunc("warn", DiagLogLevel.WARN),
+		info: _filterFunc("info", DiagLogLevel.INFO),
+		debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+		verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+	};
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/api/diag.js
+const API_NAME$2 = "diag";
+/**
+* Singleton object which represents the entry point to the OpenTelemetry internal
+* diagnostic API
+*
+* @since 1.0.0
+*/
+var DiagAPI = class DiagAPI {
+	/** Get the singleton instance of the DiagAPI API */
+	static instance() {
+		if (!this._instance) this._instance = new DiagAPI();
+		return this._instance;
+	}
+	/**
+	* Private internal constructor
+	* @private
+	*/
+	constructor() {
+		function _logProxy(funcName) {
+			return function(...args) {
+				const logger = getGlobal("diag");
+				if (!logger) return;
+				return logger[funcName](...args);
+			};
+		}
+		const self = this;
+		const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+			var _a, _b, _c;
+			if (logger === self) {
+				const err = /* @__PURE__ */ new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+				self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);
+				return false;
+			}
+			if (typeof optionsOrLogLevel === "number") optionsOrLogLevel = { logLevel: optionsOrLogLevel };
+			const oldLogger = getGlobal("diag");
+			const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+			if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+				const stack = (_c = (/* @__PURE__ */ new Error()).stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+				oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+				newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+			}
+			return registerGlobal("diag", newLogger, self, true);
+		};
+		self.setLogger = setLogger;
+		self.disable = () => {
+			unregisterGlobal(API_NAME$2, self);
+		};
+		self.createComponentLogger = (options) => {
+			return new DiagComponentLogger(options);
+		};
+		self.verbose = _logProxy("verbose");
+		self.debug = _logProxy("debug");
+		self.info = _logProxy("info");
+		self.warn = _logProxy("warn");
+		self.error = _logProxy("error");
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/context/context.js
+/**
+* Get a key to uniquely identify a context value
+*
+* @since 1.0.0
+*/
+function createContextKey(description) {
+	return Symbol.for(description);
+}
+var BaseContext = class BaseContext {
+	/**
+	* Construct a new context which inherits values from an optional parent context.
+	*
+	* @param parentContext a context from which to inherit values
+	*/
+	constructor(parentContext) {
+		const self = this;
+		self._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+		self.getValue = (key) => self._currentContext.get(key);
+		self.setValue = (key, value) => {
+			const context = new BaseContext(self._currentContext);
+			context._currentContext.set(key, value);
+			return context;
+		};
+		self.deleteValue = (key) => {
+			const context = new BaseContext(self._currentContext);
+			context._currentContext.delete(key);
+			return context;
+		};
+	}
+};
+/**
+* The root context is used as the default parent context when there is no active context
+*
+* @since 1.0.0
+*/
+const ROOT_CONTEXT = new BaseContext();
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+var NoopContextManager = class {
+	active() {
+		return ROOT_CONTEXT;
+	}
+	with(_context, fn, thisArg, ...args) {
+		return fn.call(thisArg, ...args);
+	}
+	bind(_context, target) {
+		return target;
+	}
+	enable() {
+		return this;
+	}
+	disable() {
+		return this;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/api/context.js
+const API_NAME$1 = "context";
+const NOOP_CONTEXT_MANAGER = new NoopContextManager();
+/**
+* Singleton object which represents the entry point to the OpenTelemetry Context API
+*
+* @since 1.0.0
+*/
+var ContextAPI = class ContextAPI {
+	/** Empty private constructor prevents end users from constructing a new instance of the API */
+	constructor() {}
+	/** Get the singleton instance of the Context API */
+	static getInstance() {
+		if (!this._instance) this._instance = new ContextAPI();
+		return this._instance;
+	}
+	/**
+	* Set the current context manager.
+	*
+	* @returns true if the context manager was successfully registered, else false
+	*/
+	setGlobalContextManager(contextManager) {
+		return registerGlobal(API_NAME$1, contextManager, DiagAPI.instance());
+	}
+	/**
+	* Get the currently active context
+	*/
+	active() {
+		return this._getContextManager().active();
+	}
+	/**
+	* Execute a function with an active context
+	*
+	* @param context context to be active during function execution
+	* @param fn function to execute in a context
+	* @param thisArg optional receiver to be used for calling fn
+	* @param args optional arguments forwarded to fn
+	*/
+	with(context, fn, thisArg, ...args) {
+		return this._getContextManager().with(context, fn, thisArg, ...args);
+	}
+	/**
+	* Bind a context to a target function or event emitter
+	*
+	* @param context context to bind to the event emitter or function. Defaults to the currently active context
+	* @param target function or event emitter to bind
+	*/
+	bind(context, target) {
+		return this._getContextManager().bind(context, target);
+	}
+	_getContextManager() {
+		return getGlobal(API_NAME$1) || NOOP_CONTEXT_MANAGER;
+	}
+	/** Disable and remove the global context manager */
+	disable() {
+		this._getContextManager().disable();
+		unregisterGlobal(API_NAME$1, DiagAPI.instance());
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+/**
+* @since 1.0.0
+*/
+var TraceFlags;
+(function(TraceFlags) {
+	/** Represents no flag set. */
+	TraceFlags[TraceFlags["NONE"] = 0] = "NONE";
+	/** Bit to represent whether trace is sampled in trace flags. */
+	TraceFlags[TraceFlags["SAMPLED"] = 1] = "SAMPLED";
+})(TraceFlags || (TraceFlags = {}));
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+/**
+* @since 1.0.0
+*/
+const INVALID_SPANID = "0000000000000000";
+/**
+* @since 1.0.0
+*/
+const INVALID_TRACEID = "00000000000000000000000000000000";
+/**
+* @since 1.0.0
+*/
+const INVALID_SPAN_CONTEXT = {
+	traceId: INVALID_TRACEID,
+	spanId: INVALID_SPANID,
+	traceFlags: TraceFlags.NONE
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+/**
+* The NonRecordingSpan is the default {@link Span} that is used when no Span
+* implementation is available. All operations are no-op including context
+* propagation.
+*/
+var NonRecordingSpan = class {
+	constructor(spanContext = INVALID_SPAN_CONTEXT) {
+		this._spanContext = spanContext;
+	}
+	spanContext() {
+		return this._spanContext;
+	}
+	setAttribute(_key, _value) {
+		return this;
+	}
+	setAttributes(_attributes) {
+		return this;
+	}
+	addEvent(_name, _attributes) {
+		return this;
+	}
+	addLink(_link) {
+		return this;
+	}
+	addLinks(_links) {
+		return this;
+	}
+	setStatus(_status) {
+		return this;
+	}
+	updateName(_name) {
+		return this;
+	}
+	end(_endTime) {}
+	isRecording() {
+		return false;
+	}
+	recordException(_exception, _time) {}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+/**
+* span key
+*/
+const SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+/**
+* Return the span if one exists
+*
+* @param context context to get span from
+*/
+function getSpan(context) {
+	return context.getValue(SPAN_KEY) || void 0;
+}
+/**
+* Gets the span from the current context, if one exists.
+*/
+function getActiveSpan() {
+	return getSpan(ContextAPI.getInstance().active());
+}
+/**
+* Set the span on a context
+*
+* @param context context to use as parent
+* @param span span to set active
+*/
+function setSpan(context, span) {
+	return context.setValue(SPAN_KEY, span);
+}
+/**
+* Remove current span stored in the context
+*
+* @param context context to delete span from
+*/
+function deleteSpan(context) {
+	return context.deleteValue(SPAN_KEY);
+}
+/**
+* Wrap span context in a NoopSpan and set as span in a new
+* context
+*
+* @param context context to set active span on
+* @param spanContext span context to be wrapped
+*/
+function setSpanContext(context, spanContext) {
+	return setSpan(context, new NonRecordingSpan(spanContext));
+}
+/**
+* Get the span context of the span if it exists.
+*
+* @param context context to get values from
+*/
+function getSpanContext(context) {
+	var _a;
+	return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+const isHex = new Uint8Array([
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	1,
+	1,
+	1,
+	1,
+	1,
+	1
+]);
+function isValidHex(id, length) {
+	if (typeof id !== "string" || id.length !== length) return false;
+	let r = 0;
+	for (let i = 0; i < id.length; i += 4) r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+	return r === length;
+}
+/**
+* @since 1.0.0
+*/
+function isValidTraceId(traceId) {
+	return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+}
+/**
+* @since 1.0.0
+*/
+function isValidSpanId(spanId) {
+	return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+}
+/**
+* Returns true if this {@link SpanContext} is valid.
+* @return true if this {@link SpanContext} is valid.
+*
+* @since 1.0.0
+*/
+function isSpanContextValid(spanContext) {
+	return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+}
+/**
+* Wrap the given {@link SpanContext} in a new non-recording {@link Span}
+*
+* @param spanContext span context to be wrapped
+* @returns a new non-recording {@link Span} with the provided context
+*/
+function wrapSpanContext(spanContext) {
+	return new NonRecordingSpan(spanContext);
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+const contextApi = ContextAPI.getInstance();
+/**
+* No-op implementations of {@link Tracer}.
+*/
+var NoopTracer = class {
+	startSpan(name, options, context = contextApi.active()) {
+		if (Boolean(options === null || options === void 0 ? void 0 : options.root)) return new NonRecordingSpan();
+		const parentFromContext = context && getSpanContext(context);
+		if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) return new NonRecordingSpan(parentFromContext);
+		else return new NonRecordingSpan();
+	}
+	startActiveSpan(name, arg2, arg3, arg4) {
+		let opts;
+		let ctx;
+		let fn;
+		if (arguments.length < 2) return;
+		else if (arguments.length === 2) fn = arg2;
+		else if (arguments.length === 3) {
+			opts = arg2;
+			fn = arg3;
+		} else {
+			opts = arg2;
+			ctx = arg3;
+			fn = arg4;
+		}
+		const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+		const span = this.startSpan(name, opts, parentContext);
+		const contextWithSpanSet = setSpan(parentContext, span);
+		return contextApi.with(contextWithSpanSet, fn, void 0, span);
+	}
+};
+function isSpanContext(spanContext) {
+	return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+}
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+const NOOP_TRACER = new NoopTracer();
+/**
+* Proxy tracer provided by the proxy tracer provider
+*
+* @since 1.0.0
+*/
+var ProxyTracer = class {
+	constructor(provider, name, version, options) {
+		this._provider = provider;
+		this.name = name;
+		this.version = version;
+		this.options = options;
+	}
+	startSpan(name, options, context) {
+		return this._getTracer().startSpan(name, options, context);
+	}
+	startActiveSpan(_name, _options, _context, _fn) {
+		const tracer = this._getTracer();
+		return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+	}
+	/**
+	* Try to get a tracer from the proxy tracer provider.
+	* If the proxy tracer provider has no delegate, return a noop tracer.
+	*/
+	_getTracer() {
+		if (this._delegate) return this._delegate;
+		const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+		if (!tracer) return NOOP_TRACER;
+		this._delegate = tracer;
+		return this._delegate;
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+/**
+* An implementation of the {@link TracerProvider} which returns an impotent
+* Tracer for all calls to `getTracer`.
+*
+* All operations are no-op.
+*/
+var NoopTracerProvider = class {
+	getTracer(_name, _version, _options) {
+		return new NoopTracer();
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+const NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+/**
+* Tracer provider which provides {@link ProxyTracer}s.
+*
+* Before a delegate is set, tracers provided are NoOp.
+*   When a delegate is set, traces are provided from the delegate.
+*   When a delegate is set after tracers have already been provided,
+*   all tracers already provided will use the provided delegate implementation.
+*
+* @deprecated This will be removed in the next major version.
+* @since 1.0.0
+*/
+var ProxyTracerProvider = class {
+	/**
+	* Get a {@link ProxyTracer}
+	*/
+	getTracer(name, version, options) {
+		var _a;
+		return (_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options);
+	}
+	getDelegate() {
+		var _a;
+		return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;
+	}
+	/**
+	* Set the delegate tracer provider
+	*/
+	setDelegate(delegate) {
+		this._delegate = delegate;
+	}
+	getDelegateTracer(name, version, options) {
+		var _a;
+		return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/span_kind.js
+/**
+* @since 1.0.0
+*/
+var SpanKind;
+(function(SpanKind) {
+	/** Default value. Indicates that the span is used internally. */
+	SpanKind[SpanKind["INTERNAL"] = 0] = "INTERNAL";
+	/**
+	* Indicates that the span covers server-side handling of an RPC or other
+	* remote request.
+	*/
+	SpanKind[SpanKind["SERVER"] = 1] = "SERVER";
+	/**
+	* Indicates that the span covers the client-side wrapper around an RPC or
+	* other remote request.
+	*/
+	SpanKind[SpanKind["CLIENT"] = 2] = "CLIENT";
+	/**
+	* Indicates that the span describes producer sending a message to a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["PRODUCER"] = 3] = "PRODUCER";
+	/**
+	* Indicates that the span describes consumer receiving a message from a
+	* broker. Unlike client and server, there is no direct critical path latency
+	* relationship between producer and consumer spans.
+	*/
+	SpanKind[SpanKind["CONSUMER"] = 4] = "CONSUMER";
+})(SpanKind || (SpanKind = {}));
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace/status.js
+/**
+* An enumeration of status codes.
+*
+* @since 1.0.0
+*/
+var SpanStatusCode;
+(function(SpanStatusCode) {
+	/**
+	* The default status.
+	*/
+	SpanStatusCode[SpanStatusCode["UNSET"] = 0] = "UNSET";
+	/**
+	* The operation has been validated by an Application developer or
+	* Operator to have completed successfully.
+	*/
+	SpanStatusCode[SpanStatusCode["OK"] = 1] = "OK";
+	/**
+	* The operation contains an error.
+	*/
+	SpanStatusCode[SpanStatusCode["ERROR"] = 2] = "ERROR";
+})(SpanStatusCode || (SpanStatusCode = {}));
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/api/trace.js
+const API_NAME = "trace";
+/**
+* Singleton object which represents the entry point to the OpenTelemetry Tracing API
+*
+* @since 1.0.0
+*/
+var TraceAPI = class TraceAPI {
+	/** Empty private constructor prevents end users from constructing a new instance of the API */
+	constructor() {
+		this._proxyTracerProvider = new ProxyTracerProvider();
+		this.wrapSpanContext = wrapSpanContext;
+		this.isSpanContextValid = isSpanContextValid;
+		this.deleteSpan = deleteSpan;
+		this.getSpan = getSpan;
+		this.getActiveSpan = getActiveSpan;
+		this.getSpanContext = getSpanContext;
+		this.setSpan = setSpan;
+		this.setSpanContext = setSpanContext;
+	}
+	/** Get the singleton instance of the Trace API */
+	static getInstance() {
+		if (!this._instance) this._instance = new TraceAPI();
+		return this._instance;
+	}
+	/**
+	* Set the current global tracer.
+	*
+	* @returns true if the tracer provider was successfully registered, else false
+	*/
+	setGlobalTracerProvider(provider) {
+		const success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());
+		if (success) this._proxyTracerProvider.setDelegate(provider);
+		return success;
+	}
+	/**
+	* Returns the global tracer provider.
+	*/
+	getTracerProvider() {
+		return getGlobal(API_NAME) || this._proxyTracerProvider;
+	}
+	/**
+	* Returns a tracer from the global tracer provider.
+	*/
+	getTracer(name, version) {
+		return this.getTracerProvider().getTracer(name, version);
+	}
+	/** Remove the global tracer provider */
+	disable() {
+		unregisterGlobal(API_NAME, DiagAPI.instance());
+		this._proxyTracerProvider = new ProxyTracerProvider();
+	}
+};
+
+//#endregion
+//#region ../../node_modules/@opentelemetry/api/build/esm/trace-api.js
+/**
+* Entrypoint for trace API
+*
+* @since 1.0.0
+*/
+const trace = TraceAPI.getInstance();
+
+//#endregion
+//#region ../../node_modules/@arizeai/openinference-semantic-conventions/dist/esm/trace/SemanticConventions.js
+/**
+* Semantic conventions for OpenInference tracing
+*/
+const SemanticAttributePrefixes = {
+	input: "input",
+	output: "output",
+	llm: "llm",
+	retrieval: "retrieval",
+	reranker: "reranker",
+	messages: "messages",
+	message: "message",
+	document: "document",
+	embedding: "embedding",
+	tool: "tool",
+	tool_call: "tool_call",
+	metadata: "metadata",
+	tag: "tag",
+	session: "session",
+	user: "user",
+	openinference: "openinference",
+	message_content: "message_content",
+	image: "image",
+	audio: "audio",
+	prompt: "prompt",
+	agent: "agent",
+	graph: "graph"
+};
+const LLMAttributePostfixes = {
+	provider: "provider",
+	system: "system",
+	model_name: "model_name",
+	token_count: "token_count",
+	input_messages: "input_messages",
+	output_messages: "output_messages",
+	invocation_parameters: "invocation_parameters",
+	prompts: "prompts",
+	prompt_template: "prompt_template",
+	function_call: "function_call",
+	tools: "tools",
+	cost: "cost",
+	finish_reason: "finish_reason"
+};
+const RetrievalAttributePostfixes = { documents: "documents" };
+const RerankerAttributePostfixes = {
+	input_documents: "input_documents",
+	output_documents: "output_documents",
+	query: "query",
+	model_name: "model_name",
+	top_k: "top_k"
+};
+const EmbeddingAttributePostfixes = {
+	embeddings: "embeddings",
+	text: "text",
+	model_name: "model_name",
+	vector: "vector"
+};
+const ToolAttributePostfixes = {
+	name: "name",
+	description: "description",
+	parameters: "parameters",
+	json_schema: "json_schema",
+	id: "id"
+};
+const MessageAttributePostfixes = {
+	role: "role",
+	content: "content",
+	contents: "contents",
+	name: "name",
+	function_call_name: "function_call_name",
+	function_call_arguments_json: "function_call_arguments_json",
+	tool_calls: "tool_calls",
+	tool_call_id: "tool_call_id"
+};
+const MessageContentsAttributePostfixes = {
+	type: "type",
+	text: "text",
+	image: "image",
+	id: "id",
+	signature: "signature",
+	data: "data",
+	encrypted_content: "encrypted_content"
+};
+const ImageAttributesPostfixes = { url: "url" };
+const ToolCallAttributePostfixes = {
+	function_name: "function.name",
+	function_arguments_json: "function.arguments",
+	id: "id",
+	reasoning_signature: "reasoning_signature"
+};
+const DocumentAttributePostfixes = {
+	id: "id",
+	content: "content",
+	score: "score",
+	metadata: "metadata"
+};
+const TagAttributePostfixes = { tags: "tags" };
+const SessionAttributePostfixes = { id: "id" };
+const UserAttributePostfixes = { id: "id" };
+const AudioAttributesPostfixes = {
+	url: "url",
+	mime_type: "mime_type",
+	transcript: "transcript"
+};
+const PromptAttributePostfixes = {
+	vendor: "vendor",
+	id: "id",
+	url: "url"
+};
+const AgentPostfixes = { name: "name" };
+const GraphPostfixes = {
+	node_id: "node.id",
+	node_name: "node.name",
+	node_parent_id: "node.parent_id"
+};
+/**
+* The input to any span
+*/
+const INPUT_VALUE = `${SemanticAttributePrefixes.input}.value`;
+const INPUT_MIME_TYPE = `${SemanticAttributePrefixes.input}.mime_type`;
+/**
+* The output of any span
+*/
+const OUTPUT_VALUE = `${SemanticAttributePrefixes.output}.value`;
+const OUTPUT_MIME_TYPE = `${SemanticAttributePrefixes.output}.mime_type`;
+/**
+* The messages sent to the LLM for completions
+* Typically seen in OpenAI chat completions
+* @see https://beta.openai.com/docs/api-reference/completions/create
+*/
+const LLM_INPUT_MESSAGES = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.input_messages}`;
+/**
+* The prompts sent to the LLM for completions
+* Typically seen in OpenAI legacy completions
+* @see https://beta.openai.com/docs/api-reference/completions/create
+*/
+const LLM_PROMPTS = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.prompts}`;
+/**
+* The JSON representation of the parameters passed to the LLM
+*/
+const LLM_INVOCATION_PARAMETERS = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.invocation_parameters}`;
+/**
+* The messages received from the LLM for completions
+* Typically seen in OpenAI chat completions
+* @see https://platform.openai.com/docs/api-reference/chat/object#choices-message
+*/
+const LLM_OUTPUT_MESSAGES = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.output_messages}`;
+/**
+* The name of the LLM model
+*/
+const LLM_MODEL_NAME = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.model_name}`;
+/**
+* The provider of the inferences. E.g. the cloud provider
+*/
+const LLM_PROVIDER = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.provider}`;
+/**
+* The AI product as identified by the client or server
+*/
+const LLM_SYSTEM = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.system}`;
+/** Token count for the completion by the llm (in tokens) */
+const LLM_TOKEN_COUNT_COMPLETION = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.completion`;
+/** Token count for the reasoning steps in the completion (in tokens) */
+const LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.completion_details.reasoning`;
+/** Token count for audio input generated by the model (in tokens) */
+const LLM_TOKEN_COUNT_COMPLETION_DETAILS_AUDIO = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.completion_details.audio`;
+/** Token count for the prompt to the llm (in tokens) */
+const LLM_TOKEN_COUNT_PROMPT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt`;
+/** Token count for the tokens written to cache (in tokens) */
+const LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_WRITE = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt_details.cache_write`;
+/** Token count for the tokens retrieved from cache (in tokens) */
+const LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt_details.cache_read`;
+/** Token count for the input tokens in the prompt that were cached (in tokens) */
+const LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_INPUT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt_details.cache_input`;
+/** Token count for audio input presented in the prompt (in tokens) */
+const LLM_TOKEN_COUNT_PROMPT_DETAILS_AUDIO = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt_details.audio`;
+/** Token count for the entire transaction with the llm (in tokens) */
+const LLM_TOKEN_COUNT_TOTAL = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.total`;
+/**
+* The reason the model stopped generating tokens, e.g. `"stop"` or `"length"`.
+*/
+const LLM_FINISH_REASON = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.finish_reason}`;
+/**
+* Key prefix for additional prompt token count details. Each detail should be a separate attribute
+* with this prefix, e.g. llm.token_count.prompt_details.reasoning, llm.token_count.prompt_details.audio.
+* All values should be in tokens (integer count of tokens).
+*/
+const LLM_TOKEN_COUNT_PROMPT_DETAILS = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.prompt_details`;
+/**
+* Key prefix for additional completion token count details. Each detail should be a separate attribute
+* with this prefix, e.g. llm.token_count.completion_details.reasoning, llm.token_count.completion_details.audio.
+* All values should be in tokens (integer count of tokens).
+*/
+const LLM_TOKEN_COUNT_COMPLETION_DETAILS = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.token_count}.completion_details`;
+/**
+* Key prefix for cost information. When these keys are transformed into a JSON-like structure, it would look like:
+* {
+*     "prompt": 0.0021,  # Cost in USD
+*     "completion": 0.0045,  # Cost in USD
+*     "total": 0.0066,  # Cost in USD
+*     "completion_details": {
+*         "output": 0.0009,  # Cost in USD
+*         "reasoning": 0.0024,    # Cost in USD (e.g., 80 tokens * $0.03/1K tokens)
+*         "audio": 0.0012  # Cost in USD (e.g., 40 tokens * $0.03/1K tokens)
+*     },
+*     "prompt_details": {
+*         "input": 0.0003,  # Cost in USD
+*         "cache_write": 0.0006,  # Cost in USD (e.g., 20 tokens * $0.03/1K tokens)
+*         "cache_read": 0.0003,   # Cost in USD (e.g., 10 tokens * $0.03/1K tokens)
+*         "cache_input": 0.0006,  # Cost in USD (e.g., 20 tokens * $0.03/1K tokens)
+*         "audio": 0.0003   # Cost in USD (e.g., 10 tokens * $0.03/1K tokens)
+*     }
+* }
+* Note: This is a key prefix - individual attributes are stored as separate span attributes with this prefix,
+* e.g. llm.cost.prompt, llm.cost.completion_details.reasoning, etc. The JSON structure shown above represents
+* how these separate attributes can be conceptually organized.
+* All monetary values are in USD with floating point precision.
+*/
+const LLM_COST = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}`;
+/** Cost of the prompt tokens in USD */
+const LLM_COST_PROMPT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt`;
+/** Cost of the completion tokens in USD */
+const LLM_COST_COMPLETION = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.completion`;
+/** Total cost of the LLM call in USD (prompt + completion) */
+const LLM_COST_TOTAL = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.total`;
+/** Total cost of input tokens in USD. This represents the cost of tokens that were used as input
+* to the model, which may be different from the prompt cost if there are additional processing steps. */
+const LLM_COST_INPUT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt_details.input`;
+/** Total cost of output tokens in USD. This represents the cost of tokens that were generated as output
+* by the model, which may be different from the completion cost if there are additional processing steps. */
+const LLM_COST_OUTPUT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.completion_details.output`;
+/** Cost of reasoning steps in the completion in USD */
+const LLM_COST_COMPLETION_DETAILS_REASONING = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.completion_details.reasoning`;
+/** Cost of audio tokens in the completion in USD */
+const LLM_COST_COMPLETION_DETAILS_AUDIO = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.completion_details.audio`;
+/** Cost of prompt tokens written to cache in USD */
+const LLM_COST_PROMPT_DETAILS_CACHE_WRITE = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt_details.cache_write`;
+/** Cost of prompt tokens read from cache in USD */
+const LLM_COST_PROMPT_DETAILS_CACHE_READ = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt_details.cache_read`;
+/** Cost of input tokens in the prompt that were cached in USD */
+const LLM_COST_PROMPT_DETAILS_CACHE_INPUT = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt_details.cache_input`;
+/** Cost of audio tokens in the prompt in USD */
+const LLM_COST_PROMPT_DETAILS_AUDIO = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.cost}.prompt_details.audio`;
+/**
+* The role that the LLM assumes the message is from
+* during the LLM invocation
+*/
+const MESSAGE_ROLE = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.role}`;
+/**
+* The name of the message. This is only used for role 'function' where the name
+* of the function is captured in the name field and the parameters are captured in the
+* content.
+*/
+const MESSAGE_NAME = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.name}`;
+/**
+* The tool calls generated by the model, such as function calls.
+*/
+const MESSAGE_TOOL_CALLS = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.tool_calls}`;
+/**
+* The id of the tool call on a "tool" role message
+*/
+const MESSAGE_TOOL_CALL_ID = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.tool_call_id}`;
+/**
+* tool_call.function.name
+*/
+const TOOL_CALL_FUNCTION_NAME = `${SemanticAttributePrefixes.tool_call}.${ToolCallAttributePostfixes.function_name}`;
+/**
+* tool_call.function.argument (JSON string)
+*/
+const TOOL_CALL_FUNCTION_ARGUMENTS_JSON = `${SemanticAttributePrefixes.tool_call}.${ToolCallAttributePostfixes.function_arguments_json}`;
+/**
+* The id of the tool call
+*/
+const TOOL_CALL_ID = `${SemanticAttributePrefixes.tool_call}.${ToolCallAttributePostfixes.id}`;
+/**
+* Opaque vendor-issued reasoning echo token attached to a tool call. Maps to
+* Gemini thoughtSignature when it is attached to a functionCall part
+*/
+const TOOL_CALL_REASONING_SIGNATURE = `${SemanticAttributePrefixes.tool_call}.${ToolCallAttributePostfixes.reasoning_signature}`;
+/**
+* The LLM function call function name
+*/
+const MESSAGE_FUNCTION_CALL_NAME = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.function_call_name}`;
+/**
+* The LLM function call function arguments in a json string
+*/
+const MESSAGE_FUNCTION_CALL_ARGUMENTS_JSON = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.function_call_arguments_json}`;
+/**
+* The content of the message sent to the LLM
+*/
+const MESSAGE_CONTENT = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.content}`;
+/**
+* The array of contents for the message sent to the LLM. Each element of the array is
+* an `message_content` object.
+*/
+const MESSAGE_CONTENTS = `${SemanticAttributePrefixes.message}.${MessageAttributePostfixes.contents}`;
+/**
+* The type of content sent to the LLM, such as "text", "image", "audio",
+* "reasoning", or "tool_use"
+*/
+const MESSAGE_CONTENT_TYPE = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.type}`;
+/**
+* The text content of the message sent to the LLM
+*/
+const MESSAGE_CONTENT_TEXT = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.text}`;
+/**
+* The image content of the message sent to the LLM
+*/
+const MESSAGE_CONTENT_IMAGE = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.image}`;
+/**
+* Provider-assigned identifier for this message content item. For OpenAI
+* Responses reasoning items, this maps to ResponseReasoningItem.id and should
+* be preserved for stateless replay
+*/
+const MESSAGE_CONTENT_ID = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.id}`;
+/**
+* Opaque vendor-issued signature captured verbatim. Maps to provider signature
+* fields and to Gemini thoughtSignature fields when the signature is attached
+* to a non-tool content part
+*/
+const MESSAGE_CONTENT_SIGNATURE = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.signature}`;
+/**
+* Opaque vendor-issued data captured verbatim. Maps to Anthropic
+* redacted_thinking.data
+*/
+const MESSAGE_CONTENT_DATA = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.data}`;
+/**
+* OpenAI encrypted_content captured verbatim
+*/
+const MESSAGE_CONTENT_ENCRYPTED_CONTENT = `${SemanticAttributePrefixes.message_content}.${MessageContentsAttributePostfixes.encrypted_content}`;
+/**
+* The http or base64 link to the image
+*/
+const IMAGE_URL = `${SemanticAttributePrefixes.image}.${ImageAttributesPostfixes.url}`;
+const DOCUMENT_ID = `${SemanticAttributePrefixes.document}.${DocumentAttributePostfixes.id}`;
+const DOCUMENT_CONTENT = `${SemanticAttributePrefixes.document}.${DocumentAttributePostfixes.content}`;
+const DOCUMENT_SCORE = `${SemanticAttributePrefixes.document}.${DocumentAttributePostfixes.score}`;
+const DOCUMENT_METADATA = `${SemanticAttributePrefixes.document}.${DocumentAttributePostfixes.metadata}`;
+/**
+* The text that was embedded to create the vector
+*/
+const EMBEDDING_TEXT = `${SemanticAttributePrefixes.embedding}.${EmbeddingAttributePostfixes.text}`;
+/**
+* The name of the model that was used to create the vector
+*/
+const EMBEDDING_MODEL_NAME = `${SemanticAttributePrefixes.embedding}.${EmbeddingAttributePostfixes.model_name}`;
+/**
+* The embedding vector. Typically a high dimensional vector of floats or ints
+*/
+const EMBEDDING_VECTOR = `${SemanticAttributePrefixes.embedding}.${EmbeddingAttributePostfixes.vector}`;
+/**
+* The embedding list root
+*/
+const EMBEDDING_EMBEDDINGS = `${SemanticAttributePrefixes.embedding}.${EmbeddingAttributePostfixes.embeddings}`;
+/**
+* The retrieval documents list root
+*/
+const RETRIEVAL_DOCUMENTS = `${SemanticAttributePrefixes.retrieval}.${RetrievalAttributePostfixes.documents}`;
+const PROMPT_TEMPLATE_PREFIX = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.prompt_template}`;
+/**
+* The JSON representation of the variables used in the prompt template
+*/
+const PROMPT_TEMPLATE_VARIABLES = `${PROMPT_TEMPLATE_PREFIX}.variables`;
+/**
+* A prompt template
+*/
+const PROMPT_TEMPLATE_TEMPLATE = `${PROMPT_TEMPLATE_PREFIX}.template`;
+/**
+* The JSON representation of a function call of an LLM
+*/
+const LLM_FUNCTION_CALL = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.function_call}`;
+/**
+* List of tools that are advertised to the LLM to be able to call
+*/
+const LLM_TOOLS = `${SemanticAttributePrefixes.llm}.${LLMAttributePostfixes.tools}`;
+/**
+* The name of a tool
+*/
+const TOOL_NAME$1 = `${SemanticAttributePrefixes.tool}.${ToolAttributePostfixes.name}`;
+/**
+* The description of a tool
+*/
+const TOOL_DESCRIPTION = `${SemanticAttributePrefixes.tool}.${ToolAttributePostfixes.description}`;
+/**
+* The parameters of the tool represented as a JSON string
+*/
+const TOOL_PARAMETERS = `${SemanticAttributePrefixes.tool}.${ToolAttributePostfixes.parameters}`;
+/**
+* The json schema of a tool input, It is RECOMMENDED that this be in the
+* OpenAI tool calling format: https://platform.openai.com/docs/assistants/tools
+*/
+const TOOL_JSON_SCHEMA = `${SemanticAttributePrefixes.tool}.${ToolAttributePostfixes.json_schema}`;
+/**
+* The identifier for the result of the tool call (corresponding to tool_call.id).
+*/
+const TOOL_ID = `${SemanticAttributePrefixes.tool}.${ToolAttributePostfixes.id}`;
+/**
+* The session id of a trace. Used to correlate spans in a single session.
+*/
+const SESSION_ID = `${SemanticAttributePrefixes.session}.${SessionAttributePostfixes.id}`;
+/**
+* The user id of a trace. Used to correlate spans for a single user.
+*/
+const USER_ID = `${SemanticAttributePrefixes.user}.${UserAttributePostfixes.id}`;
+/**
+* The documents used as input to the reranker
+*/
+const RERANKER_INPUT_DOCUMENTS = `${SemanticAttributePrefixes.reranker}.${RerankerAttributePostfixes.input_documents}`;
+/**
+* The documents output by the reranker
+*/
+const RERANKER_OUTPUT_DOCUMENTS = `${SemanticAttributePrefixes.reranker}.${RerankerAttributePostfixes.output_documents}`;
+/**
+* The query string for the reranker
+*/
+const RERANKER_QUERY = `${SemanticAttributePrefixes.reranker}.${RerankerAttributePostfixes.query}`;
+/**
+* The model name for the reranker
+*/
+const RERANKER_MODEL_NAME = `${SemanticAttributePrefixes.reranker}.${RerankerAttributePostfixes.model_name}`;
+/**
+* The top k parameter for the reranker
+*/
+const RERANKER_TOP_K = `${SemanticAttributePrefixes.reranker}.${RerankerAttributePostfixes.top_k}`;
+/**
+* Metadata for a span, used to store user-defined key-value pairs
+*/
+const METADATA = "metadata";
+/**
+* A prompt template version
+*/
+const PROMPT_TEMPLATE_VERSION = `${PROMPT_TEMPLATE_PREFIX}.version`;
+/**
+* The tags associated with a span
+*/
+const TAG_TAGS = `${SemanticAttributePrefixes.tag}.${TagAttributePostfixes.tags}`;
+/**
+* The url of an audio file
+*/
+const AUDIO_URL = `${SemanticAttributePrefixes.audio}.${AudioAttributesPostfixes.url}`;
+/**
+* The audio mime type
+*/
+const AUDIO_MIME_TYPE = `${SemanticAttributePrefixes.audio}.${AudioAttributesPostfixes.mime_type}`;
+/**
+* The audio transcript as text
+*/
+const AUDIO_TRANSCRIPT = `${SemanticAttributePrefixes.audio}.${AudioAttributesPostfixes.transcript}`;
+/**
+* The vendor or origin of the prompt, e.g. a prompt library, a specialized service, etc.
+*/
+const PROMPT_VENDOR = `${SemanticAttributePrefixes.prompt}.${PromptAttributePostfixes.vendor}`;
+/**
+* A vendor-specific id used to locate the prompt
+*/
+const PROMPT_ID = `${SemanticAttributePrefixes.prompt}.${PromptAttributePostfixes.id}`;
+/**
+* A vendor-specific URL used to locate the prompt
+*/
+const PROMPT_URL = `${SemanticAttributePrefixes.prompt}.${PromptAttributePostfixes.url}`;
+/**
+* The name of the agent. Agents that perform the same functions should have the same name.
+*/
+const AGENT_NAME$1 = `${SemanticAttributePrefixes.agent}.${AgentPostfixes.name}`;
+/**
+* The id of the node in the execution graph. This along with graph.node.parent_id are used to visualize the execution graph.
+*/
+const GRAPH_NODE_ID = `${SemanticAttributePrefixes.graph}.${GraphPostfixes.node_id}`;
+/**
+* The name of the node in the execution graph. Use this to present a human readable name for the node. Optional
+*/
+const GRAPH_NODE_NAME = `${SemanticAttributePrefixes.graph}.${GraphPostfixes.node_name}`;
+/**
+* This references the id of the parent node. Leaving this unset or set as empty string implies that the current span is the root node.
+*/
+const GRAPH_NODE_PARENT_ID = `${SemanticAttributePrefixes.graph}.${GraphPostfixes.node_parent_id}`;
+const SemanticConventions = {
+	IMAGE_URL,
+	INPUT_VALUE,
+	INPUT_MIME_TYPE,
+	OUTPUT_VALUE,
+	OUTPUT_MIME_TYPE,
+	LLM_INPUT_MESSAGES,
+	LLM_OUTPUT_MESSAGES,
+	LLM_MODEL_NAME,
+	LLM_PROMPTS,
+	LLM_INVOCATION_PARAMETERS,
+	LLM_TOKEN_COUNT_COMPLETION,
+	LLM_TOKEN_COUNT_COMPLETION_DETAILS,
+	LLM_TOKEN_COUNT_COMPLETION_DETAILS_REASONING,
+	LLM_TOKEN_COUNT_COMPLETION_DETAILS_AUDIO,
+	LLM_TOKEN_COUNT_PROMPT,
+	LLM_TOKEN_COUNT_PROMPT_DETAILS,
+	LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_WRITE,
+	LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_READ,
+	LLM_TOKEN_COUNT_PROMPT_DETAILS_CACHE_INPUT,
+	LLM_TOKEN_COUNT_PROMPT_DETAILS_AUDIO,
+	LLM_TOKEN_COUNT_TOTAL,
+	LLM_SYSTEM,
+	LLM_PROVIDER,
+	LLM_TOOLS,
+	LLM_FINISH_REASON,
+	LLM_COST,
+	LLM_COST_PROMPT,
+	LLM_COST_COMPLETION,
+	LLM_COST_TOTAL,
+	LLM_COST_INPUT,
+	LLM_COST_OUTPUT,
+	LLM_COST_COMPLETION_DETAILS_REASONING,
+	LLM_COST_COMPLETION_DETAILS_AUDIO,
+	LLM_COST_PROMPT_DETAILS_CACHE_WRITE,
+	LLM_COST_PROMPT_DETAILS_CACHE_READ,
+	LLM_COST_PROMPT_DETAILS_CACHE_INPUT,
+	LLM_COST_PROMPT_DETAILS_AUDIO,
+	MESSAGE_ROLE,
+	MESSAGE_NAME,
+	MESSAGE_TOOL_CALLS,
+	MESSAGE_TOOL_CALL_ID,
+	TOOL_CALL_ID,
+	TOOL_CALL_REASONING_SIGNATURE,
+	TOOL_CALL_FUNCTION_NAME,
+	TOOL_CALL_FUNCTION_ARGUMENTS_JSON,
+	MESSAGE_FUNCTION_CALL_NAME,
+	MESSAGE_FUNCTION_CALL_ARGUMENTS_JSON,
+	MESSAGE_CONTENT,
+	MESSAGE_CONTENTS,
+	MESSAGE_CONTENT_IMAGE,
+	MESSAGE_CONTENT_ID,
+	MESSAGE_CONTENT_SIGNATURE,
+	MESSAGE_CONTENT_DATA,
+	MESSAGE_CONTENT_ENCRYPTED_CONTENT,
+	MESSAGE_CONTENT_TEXT,
+	MESSAGE_CONTENT_TYPE,
+	DOCUMENT_ID,
+	DOCUMENT_CONTENT,
+	DOCUMENT_SCORE,
+	DOCUMENT_METADATA,
+	EMBEDDING_EMBEDDINGS,
+	EMBEDDING_TEXT,
+	EMBEDDING_MODEL_NAME,
+	EMBEDDING_VECTOR,
+	TOOL_DESCRIPTION,
+	TOOL_NAME: TOOL_NAME$1,
+	TOOL_PARAMETERS,
+	TOOL_JSON_SCHEMA,
+	TOOL_ID,
+	PROMPT_TEMPLATE_VARIABLES,
+	PROMPT_TEMPLATE_TEMPLATE,
+	PROMPT_TEMPLATE_VERSION,
+	RERANKER_INPUT_DOCUMENTS,
+	RERANKER_OUTPUT_DOCUMENTS,
+	RERANKER_QUERY,
+	RERANKER_MODEL_NAME,
+	RERANKER_TOP_K,
+	LLM_FUNCTION_CALL,
+	RETRIEVAL_DOCUMENTS,
+	SESSION_ID,
+	USER_ID,
+	METADATA,
+	TAG_TAGS,
+	OPENINFERENCE_SPAN_KIND: `${SemanticAttributePrefixes.openinference}.span.kind`,
+	PROMPT_VENDOR,
+	PROMPT_ID,
+	PROMPT_URL,
+	AGENT_NAME: AGENT_NAME$1,
+	GRAPH_NODE_ID,
+	GRAPH_NODE_NAME,
+	GRAPH_NODE_PARENT_ID
+};
+var OpenInferenceSpanKind;
+(function(OpenInferenceSpanKind) {
+	OpenInferenceSpanKind["LLM"] = "LLM";
+	OpenInferenceSpanKind["CHAIN"] = "CHAIN";
+	OpenInferenceSpanKind["TOOL"] = "TOOL";
+	OpenInferenceSpanKind["RETRIEVER"] = "RETRIEVER";
+	OpenInferenceSpanKind["RERANKER"] = "RERANKER";
+	OpenInferenceSpanKind["EMBEDDING"] = "EMBEDDING";
+	OpenInferenceSpanKind["AGENT"] = "AGENT";
+	OpenInferenceSpanKind["GUARDRAIL"] = "GUARDRAIL";
+	OpenInferenceSpanKind["EVALUATOR"] = "EVALUATOR";
+})(OpenInferenceSpanKind || (OpenInferenceSpanKind = {}));
+/**
+* An enum of common mime types. Not exhaustive.
+*/
+var MimeType;
+(function(MimeType) {
+	MimeType["TEXT"] = "text/plain";
+	MimeType["JSON"] = "application/json";
+	MimeType["AUDIO_WAV"] = "audio/wav";
+})(MimeType || (MimeType = {}));
+var LLMSystem;
+(function(LLMSystem) {
+	LLMSystem["OPENAI"] = "openai";
+	LLMSystem["ANTHROPIC"] = "anthropic";
+	LLMSystem["MISTRALAI"] = "mistralai";
+	LLMSystem["COHERE"] = "cohere";
+	LLMSystem["VERTEXAI"] = "vertexai";
+	LLMSystem["AI21"] = "ai21";
+	LLMSystem["META"] = "meta";
+	LLMSystem["AMAZON"] = "amazon";
+})(LLMSystem || (LLMSystem = {}));
+var LLMProvider;
+(function(LLMProvider) {
+	LLMProvider["OPENAI"] = "openai";
+	LLMProvider["ANTHROPIC"] = "anthropic";
+	LLMProvider["MISTRALAI"] = "mistralai";
+	LLMProvider["COHERE"] = "cohere";
+	LLMProvider["GOOGLE"] = "google";
+	LLMProvider["AWS"] = "aws";
+	LLMProvider["AZURE"] = "azure";
+	LLMProvider["XAI"] = "xai";
+	LLMProvider["DEEPSEEK"] = "deepseek";
+	LLMProvider["GROQ"] = "groq";
+	LLMProvider["FIREWORKS"] = "fireworks";
+	LLMProvider["MOONSHOT"] = "moonshot";
+	LLMProvider["CEREBRAS"] = "cerebras";
+	LLMProvider["PERPLEXITY"] = "perplexity";
+	LLMProvider["TOGETHER"] = "together";
+})(LLMProvider || (LLMProvider = {}));
+
+//#endregion
+//#region ../../shared/observability/src/openinference.ts
+/**
+* OpenInference semantic-convention re-exports for blinqV2.
+*
+* Phoenix (Arize) classifies spans by reading the
+* `openinference.span.kind` attribute. Without it every span shows up as
+* `UNKNOWN` in the Phoenix UI. Each blinq emitter pulls these typed
+* constants from a single place so a typo on the attribute key (or a
+* stray casing on the enum value) is a TypeScript error at the call
+* site, not a runtime miss in Phoenix.
+*
+* Reference: https://docs.arize.com/phoenix/tracing/concepts-tracing/what-are-traces
+*
+* Usage:
+*
+*   import {
+*     OpenInferenceSpanKind,
+*     OPENINFERENCE_SPAN_KIND,
+*   } from "@blinq/observability/openinference";
+*
+*   span.setAttribute(OPENINFERENCE_SPAN_KIND, OpenInferenceSpanKind.TOOL);
+*/
+/**
+* Convenience aliases for the two attribute keys blinq emitters touch
+* directly. Pulling the literal off `SemanticConventions` keeps the
+* attribute key one source of truth and lets call sites read the value
+* directly (e.g. `attributes: { [OPENINFERENCE_SPAN_KIND]: kind }`).
+*/
+const OPENINFERENCE_SPAN_KIND = SemanticConventions.OPENINFERENCE_SPAN_KIND;
+/**
+* Companion attribute used on TOOL-kind spans to surface the bounded
+* tool name (e.g. `playwright.click`, `worker.tool.execute:fillForm`).
+* Keep it bounded — high-cardinality strings here defeat the bucketing.
+*/
+const TOOL_NAME = SemanticConventions.TOOL_NAME;
+/**
+* Companion attribute used on AGENT-kind spans (the outer SSE run span)
+* so Phoenix can group runs by agent name. There's no first-class
+* constant in OpenInference for the agent label — `AGENT_NAME` covers
+* the same surface and is the convention Phoenix already understands.
+*/
+const AGENT_NAME = SemanticConventions.AGENT_NAME;
+/**
+* Companion attribute used on EVALUATOR-kind spans (postcondition
+* matcher invocations) so Phoenix can group evaluator runs by matcher
+* name. OpenInference uses `tool.name` as the canonical name slot for
+* EVALUATOR spans too; we mirror the same key for consistency with the
+* playwright tool spans that share the tracer.
+*/
+const EVALUATOR_NAME = SemanticConventions.TOOL_NAME;
+
+//#endregion
+//#region ../../core/bvt-agent/src/agent/playwright-runner.ts
+/**
+* Tracer for Playwright primitive operations driven through the sandbox
+* bridge. Spans are kept INTERNAL kind (in-process work, not a network
+* hop) and only the small set of operations users care about for the
+* `100s gap` (where time is actually spent inside a step) are wrapped —
+* `locator()` lookups and other O(1) DOM queries are intentionally
+* skipped to keep cardinality and span volume bounded.
+*/
+const playwrightActionTracer = trace.getTracer("worker.playwright.action");
+/**
+* Whitelist of page-level Playwright methods that produce a Playwright span
+* via the bridge. Keep this in sync with `TRACED_LOCATOR_METHODS` — the
+* goal is to span every operation that drives the browser (clicks,
+* navigation, waits) and skip cheap pure-DOM helpers (locator queries,
+* `url()`, `title()`) which would otherwise multiply the span count for
+* every step without adding signal.
+*/
+const TRACED_PAGE_METHODS = new Set([
+	"goto",
+	"reload",
+	"goBack",
+	"goForward",
+	"waitForURL",
+	"waitForLoadState",
+	"waitForSelector",
+	"waitForTimeout"
+]);
+const TRACED_LOCATOR_METHODS = new Set([
+	"click",
+	"fill",
+	"type",
+	"press",
+	"check",
+	"uncheck",
+	"hover",
+	"focus",
+	"selectOption",
+	"waitFor",
+	"scrollIntoViewIfNeeded",
+	"clear"
+]);
+/**
+* Extract the relevant selector / url from the first bridge arg passed to
+* a Playwright method. Avoids putting full args payloads on the span
+* (cardinality bomb when args contain DOM/JSON blobs). For locator
+* methods the selector is implicit in the receiving locator handle, so
+* we return `undefined` and let the span name carry the signal.
+*/
+function selectorAttrFromBridgeArgs(methodName, args) {
+	const first = args[0];
+	if (typeof first !== "string") return;
+	if (methodName === "goto" || methodName === "waitForURL" || methodName === "waitForSelector") return first;
+}
+/**
+* Pull a timeout out of the trailing options bag (always position 1 on
+* Playwright primitives) so the span captures what budget the call had.
+* Skip if not present — most calls inherit the page-level default and
+* surfacing `undefined` adds noise without signal.
+*/
+function timeoutAttrFromBridgeArgs(args) {
+	for (const candidate of args) if (candidate && typeof candidate === "object" && !Array.isArray(candidate) && typeof candidate.timeout === "number") return candidate.timeout;
+}
+/**
+* Wrap a Playwright primitive invocation in an INTERNAL span. Returns the
+* raw result of `fn()` so the bridge call site is unchanged. The span is
+* a no-op when the SDK is disabled — `trace.getTracer` falls back to a
+* tracer that mints non-recording spans, so the cost is one allocation
+* per call.
+*
+* The `kind` argument controls the OpenInference classification surfaced
+* to Phoenix: `TOOL` for page/locator driving actions, `EVALUATOR` for
+* postcondition matcher invocations. The bounded action/matcher name
+* lives under `tool.name` / `evaluator.name` (both alias the same
+* canonical OpenInference attribute key) so Phoenix can group dispatches
+* without re-parsing the span name. All attribute values are bounded
+* enums — no high-cardinality user input ever lands on the span.
+*/
+function tracePlaywrightAction(spanName, attrs, fn) {
+	const oiKind = attrs.kind === "EVALUATOR" ? OpenInferenceSpanKind.EVALUATOR : OpenInferenceSpanKind.TOOL;
+	const nameAttr = attrs.kind === "EVALUATOR" ? EVALUATOR_NAME : TOOL_NAME;
+	return playwrightActionTracer.startActiveSpan(spanName, {
+		kind: SpanKind.INTERNAL,
+		attributes: {
+			...attrs.selector ? { "playwright.selector": attrs.selector } : {},
+			...typeof attrs.timeout === "number" ? { "playwright.timeout": attrs.timeout } : {},
+			[OPENINFERENCE_SPAN_KIND]: oiKind,
+			[nameAttr]: spanName
+		}
+	}, (span) => {
+		let outcome;
+		try {
+			outcome = fn();
+		} catch (err) {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: err instanceof Error ? err.message : String(err)
+			});
+			if (err instanceof Error) span.recordException(err);
+			span.end();
+			throw err;
+		}
+		if (outcome instanceof Promise) return outcome.then((value) => {
+			span.end();
+			return value;
+		}, (err) => {
+			span.setStatus({
+				code: SpanStatusCode.ERROR,
+				message: err instanceof Error ? err.message : String(err)
+			});
+			if (err instanceof Error) span.recordException(err);
+			span.end();
+			throw err;
+		});
+		span.end();
+		return outcome;
+	});
+}
+/**
+* Default timeout for `expect(...).toX(...)` matchers when the caller did not
+* supply a per-call `{ timeout }` option. Matches the prior shim's default so
+* postcondition snippets compiled before the migration keep the same budget.
+*/
+const EXPECT_DEFAULT_TIMEOUT_MS = 15e3;
+/**
+* Matchers exposed to user-authored Playwright snippets via the sandbox
+* `expect()` helper. Whitelist gates which matchers cross the realm boundary,
+* keeping the surface area auditable and matching what `postcondition-compiler`
+* emits plus the handful used directly by AI-generated code.
+*/
+const SUPPORTED_EXPECT_MATCHERS = new Set([
+	"toBeVisible",
+	"toBeHidden",
+	"toBeAttached",
+	"toBeEnabled",
+	"toBeDisabled",
+	"toBeChecked",
+	"toBeFocused",
+	"toBeEditable",
+	"toBeEmpty",
+	"toBeInViewport",
+	"toHaveCount",
+	"toHaveText",
+	"toContainText",
+	"toHaveValue",
+	"toHaveValues",
+	"toHaveAttribute",
+	"toHaveClass",
+	"toHaveURL",
+	"toHaveTitle"
+]);
+/**
+* Matchers whose first arg is the expected value (string/regex/predicate/
+* number/boolean). For these the options object lives at args[1].
+* `toBeVisible/Hidden/Attached/Enabled/Disabled/Checked` take no value arg —
+* their options object sits at args[0].
+*/
+const VALUE_FIRST_EXPECT_MATCHERS = new Set([
+	"toHaveURL",
+	"toHaveTitle",
+	"toHaveText",
+	"toContainText",
+	"toHaveValue",
+	"toHaveValues",
+	"toHaveCount",
+	"toHaveClass"
+]);
+/**
+* `toHaveAttribute(name, expected?, opts?)` is special: opts is at index 2.
+* The compiler always passes `expected` explicitly (or `undefined` for the
+* presence check), so we can rely on the 3-arg layout when normalizing.
+*/
+const HAS_OPTS_AT_POSITION_2 = new Set(["toHaveAttribute"]);
+/**
+* Fills in `{ timeout: EXPECT_DEFAULT_TIMEOUT_MS }` when the caller did not
+* pass any options object. Per-call options always win — we only inject the
+* default when no options were provided at the expected position. Keeps the
+* 15s budget the prior shim used so postcondition snippets stay backward-
+* compatible without depending on `playwrightExpect.configure(...)` at module
+* load time (some tests mock `playwright/test` without `.configure`).
+*/
+function applyExpectDefaults(matcherName, args) {
+	const optsPos = HAS_OPTS_AT_POSITION_2.has(matcherName) ? 2 : VALUE_FIRST_EXPECT_MATCHERS.has(matcherName) ? 1 : 0;
+	const existing = args[optsPos];
+	if (existing && typeof existing === "object") {
+		const opts = existing;
+		if (opts.timeout !== void 0) return args;
+		const next = args.slice();
+		next[optsPos] = {
+			...opts,
+			timeout: EXPECT_DEFAULT_TIMEOUT_MS
+		};
+		return next;
+	}
+	if (existing !== void 0) return args;
+	const next = args.slice();
+	while (next.length < optsPos) next.push(void 0);
+	next[optsPos] = { timeout: EXPECT_DEFAULT_TIMEOUT_MS };
+	return next;
+}
+/**
+* Blocked methods are dangerous in a sandbox context (code execution, request
+* interception, browser/context escape, etc.).  Everything else discovered at
+* runtime on the real Playwright objects is automatically allowed, so new
+* Playwright API additions work without manual updates.
+*/
+const BLOCKED_PAGE_METHODS = new Set([
+	"evaluate",
+	"evaluateHandle",
+	"$eval",
+	"$$eval",
+	"addScriptTag",
+	"addStyleTag",
+	"exposeFunction",
+	"exposeBinding",
+	"addInitScript",
+	"route",
+	"unroute",
+	"routeFromHAR",
+	"unrouteAll",
+	"context",
+	"close",
+	"bringToFront",
+	"setContent",
+	"setExtraHTTPHeaders",
+	"setInputFiles",
+	"pdf",
+	"screenshot",
+	"video",
+	"on",
+	"off",
+	"once",
+	"emit",
+	"removeListener",
+	"removeAllListeners",
+	"addListener",
+	"setMaxListeners",
+	"waitForEvent",
+	"workers",
+	"frames",
+	"mainFrame",
+	"opener"
+]);
+const BLOCKED_LOCATOR_METHODS = new Set([
+	"evaluate",
+	"evaluateHandle",
+	"evaluateAll",
+	"on",
+	"off",
+	"once",
+	"emit",
+	"removeListener",
+	"removeAllListeners",
+	"addListener",
+	"setMaxListeners",
+	"setInputFiles",
+	"screenshot"
+]);
+/**
+* Walk the prototype chain and collect every function-valued own-property.
+* Uses property descriptors to avoid triggering getters/accessors (e.g.
+* Playwright's `keyboard`, `mouse` accessors) during introspection.
+*/
+function extractMethods(obj) {
+	const methods = /* @__PURE__ */ new Set();
+	let current = obj;
+	while (current && current !== Object.prototype) {
+		for (const key of Object.getOwnPropertyNames(current)) {
+			const descriptor = Object.getOwnPropertyDescriptor(current, key);
+			if (key !== "constructor" && descriptor && typeof descriptor.value === "function") methods.add(key);
+		}
+		current = Object.getPrototypeOf(current);
+	}
+	return [...methods];
+}
+const HOST_HELPER_METHODS = [
+	"getPreferredInteractiveTargetSelector",
+	"activatePreferredInteractiveTarget",
+	"activateWithRecovery"
+];
+const FALLBACK_PAGE_METHODS = [
+	"getByAltText",
+	"getByDisplayValue",
+	"getByLabel",
+	"getByPlaceholder",
+	"getByRole",
+	"getByTestId",
+	"getByText",
+	"getByTitle",
+	"goto",
+	"reload",
+	"goBack",
+	"goForward",
+	"locator",
+	"title",
+	"url",
+	"waitForSelector",
+	"waitForTimeout",
+	"waitForURL",
+	"waitForLoadState"
+];
+const FALLBACK_LOCATOR_METHODS = [
+	"allTextContents",
+	"and",
+	"blur",
+	"check",
+	"clear",
+	"click",
+	"count",
+	"fill",
+	"filter",
+	"first",
+	"focus",
+	"getAttribute",
+	"getByAltText",
+	"getByDisplayValue",
+	"getByLabel",
+	"getByPlaceholder",
+	"getByRole",
+	"getByTestId",
+	"getByText",
+	"getByTitle",
+	"hover",
+	"innerText",
+	"inputValue",
+	"isChecked",
+	"isDisabled",
+	"isEnabled",
+	"isHidden",
+	"isVisible",
+	"last",
+	"locator",
+	"nth",
+	"or",
+	"press",
+	"scrollIntoViewIfNeeded",
+	"selectOption",
+	"textContent",
+	"type",
+	"uncheck",
+	"waitFor"
+];
+function buildAllowedMethods(obj, blocked, fallback) {
+	let all = extractMethods(obj);
+	if (all.length === 0) all = fallback;
+	const methods = all.filter((m) => !blocked.has(m));
+	return {
+		methods,
+		methodSet: new Set(methods)
+	};
+}
+const HELPER_METHOD_SET = new Set(HOST_HELPER_METHODS);
+const BRIDGE_ERROR_PREFIX = "[playwright-bridge]";
+const RECOVERY_LOCATOR_OPERATION_TIMEOUT_MS = 2e3;
+function recoveryLocatorOptions(extra) {
 	return {
 		timeout: RECOVERY_LOCATOR_OPERATION_TIMEOUT_MS,
 		...extra
@@ -18099,6 +19973,19 @@ function buildBootstrap(code, pageMethods, locatorMethods) {
   });
 
   const testData = Object.freeze({
+    set: async (key, value, opts) => {
+      const result = __bridgeTestData("set", [key, value, opts]);
+      if (result && typeof result.then === "function") {
+        const resolved = await result;
+        return resolved && resolved.type === "value" ? resolved.value : undefined;
+      }
+      return undefined;
+    },
+    get: async (key) => {
+      const result = __bridgeTestData("get", [key]);
+      const resolved = result && typeof result.then === "function" ? await result : result;
+      return resolved && resolved.type === "value" ? resolved.value : null;
+    },
     setRuntime: async (key, value, opts) => {
       const result = __bridgeTestData("setRuntime", [key, value, opts]);
       if (result && typeof result.then === "function") {
@@ -18158,234 +20045,35 @@ function buildBootstrap(code, pageMethods, locatorMethods) {
     }
   };
 
-  // ── Minimal expect() shim for postcondition snippets ────────────────────
-  // Not a full Playwright @playwright/test expect; covers common matchers.
-  // Supports .not inversion and { timeout } option on every matcher.
-  const EXPECT_DEFAULT_TIMEOUT_MS = 15000;
-  const EXPECT_POLL_INTERVAL_MS = 100;
-  const expectRegexOrStringEq = (actual, expected) => {
-    const str = actual == null ? "" : String(actual);
-    if (expected instanceof RegExp) return expected.test(str);
-    return str === String(expected);
-  };
-  const expectRegexOrStringContains = (actual, expected) => {
-    const str = actual == null ? "" : String(actual);
-    if (expected instanceof RegExp) return expected.test(str);
-    return str.includes(String(expected));
-  };
-  const expectPoll = async (predicate, timeout, errorBuilder) => {
-    const deadline = Date.now() + timeout;
-    let lastDetail = "<never observed>";
-    while (Date.now() < deadline) {
-      try {
-        const result = await predicate();
-        if (result && result.ok) return;
-        if (result && result.detail !== undefined) lastDetail = result.detail;
-      } catch (err) {
-        lastDetail = err && err.message ? err.message : String(err);
-      }
-      const remaining = deadline - Date.now();
-      if (remaining <= 0) break;
-      await __bridgeDelay(Math.min(EXPECT_POLL_INTERVAL_MS, remaining));
-    }
-    throw new Error(errorBuilder(lastDetail));
+  // ── expect() bridge to Playwright's official @playwright/test expect ──
+  // The user-authored code runs inside this vm context; the real Playwright
+  // page/locator objects live in the host realm. Each matcher call is shipped
+  // across the bridge as a single (matcherName, subjectRef, args, negate)
+  // tuple so the host can invoke the official expect on the real subject —
+  // preserving function-predicate, cross-realm RegExp, polling/intervals,
+  // and the full matcher message format that ships with Playwright.
+  const buildExpectChain = (subjectRef, negate) => {
+    const handler = {
+      get(_target, prop) {
+        if (prop === "not") {
+          return buildExpectChain(subjectRef, !negate);
+        }
+        if (typeof prop !== "string") {
+          return undefined;
+        }
+        return (...args) => __bridgeExpect(prop, subjectRef, args, negate);
+      },
+    };
+    return new Proxy(Object.create(null), handler);
   };
   const expect = (subject) => {
-    const isLocator = subject != null && typeof subject.__locatorId === "number";
-    const isPage = subject === page;
-    const ensureLocator = (matcher) => {
-      if (!isLocator) throw new Error(matcher + " requires a locator subject");
-    };
-    const ensurePage = (matcher) => {
-      if (!isPage) throw new Error(matcher + " requires a page subject");
-    };
-    const make = (negate) => {
-      const flip = (ok) => (negate ? !ok : ok);
-      const flipWord = negate ? "NOT " : "";
-      const api = {
-        async toBeVisible(opts = {}) {
-          ensureLocator("toBeVisible");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await subject.waitFor({ state: negate ? "hidden" : "visible", timeout: timeout });
-        },
-        async toBeHidden(opts = {}) {
-          ensureLocator("toBeHidden");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await subject.waitFor({ state: negate ? "visible" : "hidden", timeout: timeout });
-        },
-        async toBeAttached(opts = {}) {
-          ensureLocator("toBeAttached");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await subject.waitFor({ state: negate ? "detached" : "attached", timeout: timeout });
-        },
-        async toBeEnabled(opts = {}) {
-          ensureLocator("toBeEnabled");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const enabled = await subject.isEnabled();
-              return flip(enabled) ? { ok: true } : { ok: false, detail: "isEnabled=" + enabled };
-            },
-            timeout,
-            (detail) => "Expected locator " + flipWord + "to be enabled. Last: " + detail,
-          );
-        },
-        async toBeDisabled(opts = {}) {
-          ensureLocator("toBeDisabled");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const disabled = await subject.isDisabled();
-              return flip(disabled) ? { ok: true } : { ok: false, detail: "isDisabled=" + disabled };
-            },
-            timeout,
-            (detail) => "Expected locator " + flipWord + "to be disabled. Last: " + detail,
-          );
-        },
-        async toBeChecked(opts = {}) {
-          ensureLocator("toBeChecked");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const checked = await subject.isChecked();
-              return flip(checked) ? { ok: true } : { ok: false, detail: "isChecked=" + checked };
-            },
-            timeout,
-            (detail) => "Expected locator " + flipWord + "to be checked. Last: " + detail,
-          );
-        },
-        async toHaveCount(expected, opts = {}) {
-          ensureLocator("toHaveCount");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const count = await subject.count();
-              return flip(count === expected)
-                ? { ok: true }
-                : { ok: false, detail: "count=" + count };
-            },
-            timeout,
-            (detail) => "Expected count " + flipWord + "to equal " + expected + ". Last: " + detail,
-          );
-        },
-        async toHaveText(expected, opts = {}) {
-          ensureLocator("toHaveText");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const text = await subject.textContent();
-              return flip(expectRegexOrStringEq(text, expected))
-                ? { ok: true }
-                : { ok: false, detail: "textContent=" + JSON.stringify(text) };
-            },
-            timeout,
-            (detail) =>
-              "Expected text " + flipWord + "to match " + String(expected) + ". Last: " + detail,
-          );
-        },
-        async toContainText(expected, opts = {}) {
-          ensureLocator("toContainText");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const text = await subject.textContent();
-              return flip(expectRegexOrStringContains(text, expected))
-                ? { ok: true }
-                : { ok: false, detail: "textContent=" + JSON.stringify(text) };
-            },
-            timeout,
-            (detail) =>
-              "Expected text " +
-              flipWord +
-              "to contain " +
-              String(expected) +
-              ". Last: " +
-              detail,
-          );
-        },
-        async toHaveValue(expected, opts = {}) {
-          ensureLocator("toHaveValue");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const value = await subject.inputValue();
-              return flip(expectRegexOrStringEq(value, expected))
-                ? { ok: true }
-                : { ok: false, detail: "inputValue=" + JSON.stringify(value) };
-            },
-            timeout,
-            (detail) =>
-              "Expected value " + flipWord + "to equal " + String(expected) + ". Last: " + detail,
-          );
-        },
-        async toHaveAttribute(name, expected, opts = {}) {
-          ensureLocator("toHaveAttribute");
-          const timeout = (opts && opts.timeout) ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const actual = await subject.getAttribute(name);
-              if (expected === undefined) {
-                return flip(actual !== null)
-                  ? { ok: true }
-                  : { ok: false, detail: "attr[" + name + "]=" + JSON.stringify(actual) };
-              }
-              return flip(expectRegexOrStringEq(actual, expected))
-                ? { ok: true }
-                : { ok: false, detail: "attr[" + name + "]=" + JSON.stringify(actual) };
-            },
-            timeout,
-            (detail) =>
-              "Expected attribute " +
-              name +
-              " " +
-              flipWord +
-              "to match. Last: " +
-              detail,
-          );
-        },
-        async toHaveURL(expected, opts = {}) {
-          ensurePage("toHaveURL");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          // Poll page.url() instead of page.waitForURL. waitForURL waits for a
-          // NEW navigation event and does not short-circuit when navigation
-          // has already settled before the call (common for fast clicks).
-          await expectPoll(
-            async () => {
-              const url = await page.url();
-              const ok = expectRegexOrStringEq(url, expected);
-              return flip(ok)
-                ? { ok: true }
-                : { ok: false, detail: "url=" + String(url) };
-            },
-            timeout,
-            (detail) =>
-              "Expected URL " + flipWord + "to match " + String(expected) + ". Last: " + detail,
-          );
-        },
-        async toHaveTitle(expected, opts = {}) {
-          ensurePage("toHaveTitle");
-          const timeout = opts.timeout ?? EXPECT_DEFAULT_TIMEOUT_MS;
-          await expectPoll(
-            async () => {
-              const title = await page.title();
-              return flip(expectRegexOrStringEq(title, expected))
-                ? { ok: true }
-                : { ok: false, detail: "title=" + JSON.stringify(title) };
-            },
-            timeout,
-            (detail) =>
-              "Expected title " + flipWord + "to match " + String(expected) + ". Last: " + detail,
-          );
-        },
-      };
-      Object.defineProperty(api, "not", {
-        get() {
-          return make(!negate);
-        },
-      });
-      return api;
-    };
-    return make(false);
+    if (subject === page) {
+      return buildExpectChain({ kind: "page" }, false);
+    }
+    if (subject != null && typeof subject.__locatorId === "number") {
+      return buildExpectChain({ kind: "locator", locatorId: subject.__locatorId }, false);
+    }
+    throw new Error("expect() requires the sandbox page or a sandbox locator as its subject");
   };
 
   return (async (page, context, console, checkpoint, helpers, expect, onCommandStart, onCommandPass) => {
@@ -18434,10 +20122,15 @@ function raceWithAbort(promise, signal) {
 }
 function isLocatorLike(value) {
 	if (!value || typeof value !== "object" && typeof value !== "function") return false;
+	if (Array.isArray(value)) return false;
 	const candidate = value;
 	return FALLBACK_LOCATOR_METHODS.some((methodName) => typeof candidate[methodName] === "function");
 }
 function bridgeResultFromValue(value, locatorIds, locators) {
+	if (Array.isArray(value)) return {
+		type: "array",
+		items: value.map((item) => bridgeResultFromValue(item, locatorIds, locators))
+	};
 	if (isLocatorLike(value)) {
 		const locatorObject = value;
 		const existingLocatorId = locatorIds.get(locatorObject);
@@ -18668,7 +20361,7 @@ async function activateWithRecovery(page, locator) {
 function invokeHelperMethod(helperName, args, page, locatorIds, locators) {
 	if (!HELPER_METHOD_SET.has(helperName)) throw new Error(`${BRIDGE_ERROR_PREFIX} Blocked helper call: ${helperName}`);
 	const [firstArg] = args;
-	const resolvedLocator = firstArg?.type === "locator" ? locators.get(firstArg.locatorId) : firstArg?.value;
+	const resolvedLocator = firstArg?.type === "locator" ? locators.get(firstArg.locatorId) : firstArg?.type === "value" ? firstArg.value : void 0;
 	const helperResult = helperName === "getPreferredInteractiveTargetSelector" ? getPreferredInteractiveTargetSelector(resolvedLocator) : helperName === "activatePreferredInteractiveTarget" ? activatePreferredInteractiveTarget(page, resolvedLocator) : helperName === "activateWithRecovery" ? activateWithRecovery(page, resolvedLocator) : resolvedLocator;
 	if (helperResult instanceof Promise) return helperResult.then((value) => bridgeResultFromValue(value, locatorIds, locators));
 	return bridgeResultFromValue(helperResult, locatorIds, locators);
@@ -18722,18 +20415,64 @@ async function runPlaywrightCode({ page, code, context, timeoutMs, signal, onLog
 	sandbox.__bridgeCheckpoint = (label, data) => {
 		onCheckpoint(label, data === void 0 ? void 0 : cloneSerializableValue(data));
 	};
-	sandbox.__bridgePage = (methodName, args) => invokeBridgeMethod(page, methodName, args, allowedPage.methodSet, locatorIds, locators, signal);
+	sandbox.__bridgePage = (methodName, args) => {
+		const invoke = () => invokeBridgeMethod(page, methodName, args, allowedPage.methodSet, locatorIds, locators, signal);
+		if (!TRACED_PAGE_METHODS.has(methodName)) return invoke();
+		return tracePlaywrightAction(`playwright.${methodName}`, {
+			selector: selectorAttrFromBridgeArgs(methodName, args),
+			timeout: timeoutAttrFromBridgeArgs(args)
+		}, invoke);
+	};
 	sandbox.__bridgeLocator = (locatorId, methodName, args) => {
 		const locator = locators.get(locatorId);
 		if (!locator) throw new Error(`${BRIDGE_ERROR_PREFIX} Unknown locator handle: ${locatorId}`);
-		return invokeBridgeMethod(locator, methodName, args, allowedLocator.methodSet, locatorIds, locators, signal);
+		const invoke = () => invokeBridgeMethod(locator, methodName, args, allowedLocator.methodSet, locatorIds, locators, signal);
+		if (!TRACED_LOCATOR_METHODS.has(methodName)) return invoke();
+		return tracePlaywrightAction(`playwright.${methodName}`, { timeout: timeoutAttrFromBridgeArgs(args) }, invoke);
 	};
 	sandbox.__bridgeHelper = (helperName, args) => invokeHelperMethod(helperName, args, page, locatorIds, locators);
+	sandbox.__bridgeExpect = (matcherName, subjectRef, args, negate) => {
+		if (!SUPPORTED_EXPECT_MATCHERS.has(matcherName)) throw new Error(`${BRIDGE_ERROR_PREFIX} expect matcher not supported: ${matcherName}`);
+		let subject;
+		if (subjectRef.kind === "page") subject = page;
+		else {
+			const real = locators.get(subjectRef.locatorId);
+			if (!real) throw new Error(`${BRIDGE_ERROR_PREFIX} Unknown locator handle for expect: ${subjectRef.locatorId}`);
+			subject = real;
+		}
+		const normalizedArgs = applyExpectDefaults(matcherName, args);
+		const expectation = negate ? expect(subject).not : expect(subject);
+		const matcher = expectation[matcherName];
+		if (typeof matcher !== "function") throw new Error(`${BRIDGE_ERROR_PREFIX} expect().${matcherName} is not available on the subject`);
+		return tracePlaywrightAction(`playwright.postcondition.${matcherName}`, {
+			timeout: timeoutAttrFromBridgeArgs(normalizedArgs),
+			kind: "EVALUATOR"
+		}, () => {
+			const result = Reflect.apply(matcher, expectation, normalizedArgs);
+			if (result instanceof Promise) return raceWithAbort(result, signal);
+			return result;
+		});
+	};
 	sandbox.__bridgeDelay = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, Number(ms) || 0)));
 	sandbox.__bridgeTestData = async (methodName, args) => {
 		const api = testData;
 		if (!api) throw new Error("context.testData is not available (testData is not available) — no resolutionContext on this step");
 		switch (methodName) {
+			case "set": {
+				const [key, value, opts] = args;
+				await api.set(key, value, opts);
+				return {
+					type: "value",
+					value: void 0
+				};
+			}
+			case "get": {
+				const [key] = args;
+				return {
+					type: "value",
+					value: await api.get(key)
+				};
+			}
 			case "setRuntime": {
 				const [key, value, opts] = args;
 				await api.setRuntime(key, value, opts);
@@ -18878,6 +20617,11 @@ async function executePlaywrightCode({ page, code, context, timeoutMs = PLAYWRIG
 //#endregion
 //#region ../../core/bvt-agent/src/agent/utils.ts
 const hasUnresolvedTokens = (obj) => {
+	if (obj && typeof obj === "object" && obj.type === "custom.code") {
+		const { code: _code, ...rest } = obj;
+		const str = JSON.stringify(rest);
+		return /{{.*}}/.test(str);
+	}
 	const str = JSON.stringify(obj);
 	return /{{.*}}/.test(str);
 };
@@ -19147,13 +20891,14 @@ var Tester = class {
 	fileResolver;
 	downloadStore;
 	getDownloadTargetPath;
+	customCodeRuntime;
 	pageList = new Array();
 	sessionToken = "";
 	activeBrowserContext = null;
 	reportId = ulid();
 	constructor(getAPIClient = unconfiguredGetAPIClient, observabilityOrOptions, optionsArg = {}) {
 		this.getAPIClient = getAPIClient;
-		const isTesterOptions = observabilityOrOptions !== null && typeof observabilityOrOptions === "object" && ("commandPreprocessors" in observabilityOrOptions || "recoveryController" in observabilityOrOptions || "restoreStepStartForRepair" in observabilityOrOptions || "provider" in observabilityOrOptions || "getApiFetchImpl" in observabilityOrOptions || "stepTraceChunkCallbacks" in observabilityOrOptions || "context" in observabilityOrOptions || "onTestDataChange" in observabilityOrOptions);
+		const isTesterOptions = observabilityOrOptions !== null && typeof observabilityOrOptions === "object" && ("commandPreprocessors" in observabilityOrOptions || "recoveryController" in observabilityOrOptions || "restoreStepStartForRepair" in observabilityOrOptions || "provider" in observabilityOrOptions || "getApiFetchImpl" in observabilityOrOptions || "stepTraceChunkCallbacks" in observabilityOrOptions || "context" in observabilityOrOptions || "onTestDataChange" in observabilityOrOptions || "customCodeRuntime" in observabilityOrOptions);
 		const observability = isTesterOptions ? void 0 : observabilityOrOptions;
 		const options = isTesterOptions ? observabilityOrOptions : optionsArg;
 		this.obs = resolveAgentObservability(observability);
@@ -19168,6 +20913,7 @@ var Tester = class {
 		this.fileResolver = options.fileResolver;
 		this.downloadStore = options.downloadStore;
 		this.getDownloadTargetPath = options.getDownloadTargetPath;
+		this.customCodeRuntime = options.customCodeRuntime;
 	}
 	setContext(context) {
 		this.dataContext = context;
@@ -19213,6 +20959,7 @@ var Tester = class {
 	getCommandText(command) {
 		switch (command.type) {
 			case "custom": return `Custom`;
+			case "custom.code": return "Custom code";
 			case "element.action":
 			case "element.assertion": return `${command.data.type} ${command.target.name ? `"${command.target.name}"` : ""}`.trim();
 			case "element.extract": return `${command.data.type} ${command.target.name ? `"${command.target.name}"` : ""}`.trim();
@@ -19579,7 +21326,7 @@ var Tester = class {
 					command,
 					context: commandContext
 				});
-				if (command.type === "custom" && commandResult && isFailedCustomCommandResult(commandResult)) throw new Error(commandResult.error || `Custom command "${command._id}" failed.`);
+				if ((command.type === "custom" || command.type === "custom.code") && commandResult && isFailedCustomCommandResult(commandResult)) throw new Error(commandResult.error || `Custom command "${command._id}" failed.`);
 				this.obs.logger.log(`Finished executing command: ${command}`);
 				yield await this.onCommandPass(command, stepDefinitionId, session);
 			} catch (error) {
@@ -20513,28 +22260,63 @@ var Tester = class {
 					const data = command.data;
 					await this.executeUtilityCommand(data, input.page, context);
 					return;
-				case "custom": return executePlaywrightCode({
-					page: input.page,
-					code: command.code,
-					context: {
-						stepId: command._id,
-						variables: context.stepParameters ?? {}
-					},
-					testData: context.testDataApi,
-					signal: context.abortSignal,
-					traceDelegate: {
-						startGroup: async (name) => {
-							try {
-								await this.activeBrowserContext?.tracing.group(name);
-							} catch {}
-						},
-						endGroup: async () => {
-							try {
-								await this.activeBrowserContext?.tracing.groupEnd();
-							} catch {}
-						}
+				case "custom": {
+					const defaultDialogHandler = (dialog) => {
+						dialog.dismiss().catch(() => {});
+					};
+					const pageAsEventEmitter = input.page;
+					const hasDialogSupport = typeof pageAsEventEmitter.on === "function" && typeof pageAsEventEmitter.off === "function";
+					if (hasDialogSupport) pageAsEventEmitter.on("dialog", defaultDialogHandler);
+					try {
+						return await executePlaywrightCode({
+							page: input.page,
+							code: command.code,
+							context: {
+								stepId: command._id,
+								variables: context.stepParameters ?? {}
+							},
+							testData: context.testDataApi,
+							signal: context.abortSignal,
+							traceDelegate: {
+								startGroup: async (name) => {
+									try {
+										await this.activeBrowserContext?.tracing.group(name);
+									} catch {}
+								},
+								endGroup: async () => {
+									try {
+										await this.activeBrowserContext?.tracing.groupEnd();
+									} catch {}
+								}
+							}
+						});
+					} finally {
+						if (hasDialogSupport) pageAsEventEmitter.off("dialog", defaultDialogHandler);
 					}
-				});
+				}
+				case "custom.code": {
+					if (!this.customCodeRuntime) return {
+						success: false,
+						error: "Custom code runtime is not configured for this worker.",
+						errorKind: "feature_disabled"
+					};
+					const fetchImpl = this.getApiFetchImpl?.() ?? fetch;
+					return await this.customCodeRuntime.execute({
+						commandId: command._id,
+						code: command.code,
+						variables: context.stepParameters ?? {},
+						page: input.page,
+						testData: context.testDataApi,
+						fetchImpl,
+						checkpoint: async (label, data) => {
+							this.obs.logger.info("customCode.checkpoint", {
+								label,
+								data
+							});
+						},
+						signal: context.abortSignal
+					});
+				}
 				case "api.action": {
 					const fetchImpl = this.getApiFetchImpl?.();
 					const apiResponse = await executeApiRequest(command.data, {
@@ -20573,12 +22355,24 @@ var Tester = class {
 			});
 		}
 	}
-	async extractToTestData(input) {
-		if (!this.dataProvider || !this.dataContext) return;
-		await new TestDataApi(this.dataProvider, this.dataContext, {
+	/**
+	* Runtime test-data accessor bound to the tester's current data provider and
+	* resolution context. Returns `undefined` when no provider/context is
+	* configured (e.g. a tester constructed without a test-data layer). A fresh
+	* instance is returned each access so it always reflects the latest context
+	* set via `setContext`.
+	*/
+	get testDataApi() {
+		if (!this.dataProvider || !this.dataContext) return void 0;
+		return new TestDataApi(this.dataProvider, this.dataContext, {
 			onChange: this.onTestDataChange,
 			logger: this.obs.logger
-		}).setRuntime(input.key, input.value, { dataType: input.dataType });
+		});
+	}
+	async extractToTestData(input) {
+		const api = this.testDataApi;
+		if (!api) return;
+		await api.setRuntime(input.key, input.value, { dataType: input.dataType });
 	}
 	async executePageExtraction(page, extract, storageDetails) {
 		switch (extract.type) {
@@ -20746,6 +22540,13 @@ function createDataResolverPreprocessor(resolver) {
 				code
 			};
 		}
+		if (command.type === "custom.code" && typeof command.code === "string") {
+			const { code, ...rest } = command;
+			return {
+				...await resolver.resolveObject(rest, context.resolutionContext),
+				code
+			};
+		}
 		return resolver.resolveObject(command, context.resolutionContext);
 	};
 }
@@ -23724,6 +25525,16 @@ function resolveSelectorString(selector) {
 	if (selector.type === "pw.selectorString") return selector.selectorString;
 	throw new Error(`Unsupported selector type "${selector.type}". bvt-playwright-js currently only resolves "pw.selectorString". Support for "bvt.selectorObject" needs to be ported from bvt-agent.`);
 }
+function toMatcherValue(value) {
+	if (value === void 0) return;
+	switch (value.type) {
+		case "string":
+		case "number":
+		case "boolean": return value.value;
+		case "regex": return new RegExp(value.source, value.flags);
+		default: throw new Error(`Invalid matcher value: unknown type "${value.type}"`);
+	}
+}
 const DEFAULT_PROJECT_ID = "01K00000000000000000000000";
 const BLINQ_ENVIRONMENT_ENV_VAR = "BLINQ_ENVIRONMENT";
 function toFilePath(target) {
@@ -24068,10 +25879,13 @@ function createBlinqTest(options = {}) {
 			...runtimeFilePath ? { testDataFilePath: runtimeFilePath } : { testDataFilePath: path.join(tmpdir(), `blinq-bvt-playwright-${process.pid}-${testInfo.workerIndex}-${testInfo.testId}.json`) }
 		} }, { logger });
 		runner.attach(page);
+		const testDataApi = runner.tester.testDataApi;
+		if (!testDataApi) throw new Error("bvt.testDataApi is unavailable: the runner has no test-data provider/context. Extract steps require a configured test-data layer.");
 		try {
 			await use({
 				page,
 				parameters: runner.parameters,
+				testDataApi,
 				executeCommand: (command, stepParameters) => runner.executeCommand(command, stepParameters),
 				resolveCommand: (command, stepParameters) => runner.resolveCommand(command, stepParameters),
 				find: (command) => runner.find(command),
@@ -24089,5 +25903,5 @@ function createBlinqTest(options = {}) {
 }
 
 //#endregion
-export { PlaywrightRunner, TempFileTestDataProvider, createBlinqTest, createBlinqTest as default };
+export { PlaywrightRunner, TempFileTestDataProvider, createBlinqTest, createBlinqTest as default, toMatcherValue };
 //# sourceMappingURL=index.mjs.map