@theaiplatform/miniapp-sdk 0.3.3 → 0.4.0

package/dist/testing/rstest.js

@@ -1,120 +1,1530 @@
 import * as __rspack_external__rstest_playwright_5734ff29 from "@rstest/playwright";
+import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
 import * as __rspack_external_node_fs_promises_3b710708 from "node:fs/promises";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_playwright from "playwright";
 import * as __rspack_external_zod from "zod";
-const SESSION_ENV = 'TAP_MINIAPP_TEST_SESSION_FILE';
-const sessionSchema = __rspack_external_zod.z.object({
-    schemaVersion: __rspack_external_zod.z.literal(1),
-    runId: __rspack_external_zod.z.string().min(1),
-    workspaceId: __rspack_external_zod.z.string().min(1),
-    channelId: __rspack_external_zod.z.string().min(1),
-    packageId: __rspack_external_zod.z.string().min(1),
-    installationId: __rspack_external_zod.z.string().min(1),
-    mode: __rspack_external_zod.z["enum"]([
-        'surface',
-        'live-tap'
-    ]),
-    dataScope: __rspack_external_zod.z["enum"]([
-        'fixture',
-        'selected-channel'
-    ]),
-    permissionScenario: __rspack_external_zod.z.string().min(1),
-    surfaceId: __rspack_external_zod.z.string().min(1),
-    surfaceSelector: __rspack_external_zod.z.string().min(1),
-    surfaceAssetOrigin: __rspack_external_zod.z.string().url(),
-    pageUrlPrefix: __rspack_external_zod.z.string().url(),
-    cdpEndpoint: __rspack_external_zod.z.string().url(),
-    cdpAuthorization: __rspack_external_zod.z.string().min(1),
-    artifactDirectory: __rspack_external_zod.z.string().min(1),
-    allowedNetworkOrigins: __rspack_external_zod.z.array(__rspack_external_zod.z.string().url()).max(128),
-    credentialAliases: __rspack_external_zod.z.array(__rspack_external_zod.z.string().min(1).max(256)).max(64),
-    releaseDigest: __rspack_external_zod.z.string().min(1).optional(),
-    localGeneration: __rspack_external_zod.z.number().int().nonnegative().optional(),
-    sourceDigest: __rspack_external_zod.z.string().min(1),
-    testBundleDigest: __rspack_external_zod.z.string().min(1)
+import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
+import * as __rspack_external_node_util_types_4d803828 from "node:util/types";
+const jsonValueSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.lazy(()=>__rspack_external_zod.z.union([
+            __rspack_external_zod.z["null"](),
+            __rspack_external_zod.z.boolean(),
+            __rspack_external_zod.z.number(),
+            __rspack_external_zod.z.string(),
+            __rspack_external_zod.z.array(jsonValueSchema),
+            __rspack_external_zod.z.record(__rspack_external_zod.z.string(), jsonValueSchema)
+        ])))();
+const _miniappTestArtifactSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        artifactId: __rspack_external_zod.z.string(),
+        kind: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_ARTIFACT_KIND_RUN_MANIFEST',
+            'MINIAPP_TEST_ARTIFACT_KIND_JSON_REPORT',
+            'MINIAPP_TEST_ARTIFACT_KIND_MARKDOWN_REPORT',
+            'MINIAPP_TEST_ARTIFACT_KIND_SCREENSHOT',
+            'MINIAPP_TEST_ARTIFACT_KIND_TRACE',
+            'MINIAPP_TEST_ARTIFACT_KIND_TRACE_SUMMARY',
+            'MINIAPP_TEST_ARTIFACT_KIND_DEBUG_REPORT',
+            'MINIAPP_TEST_ARTIFACT_KIND_CONSOLE_LOG',
+            'MINIAPP_TEST_ARTIFACT_KIND_NETWORK_LOG'
+        ]),
+        relativeVfsPath: __rspack_external_zod.z.string(),
+        contentSha256: __rspack_external_zod.z.string(),
+        mediaType: __rspack_external_zod.z.string(),
+        byteLength: __rspack_external_zod.z.number(),
+        redacted: __rspack_external_zod.z.boolean(),
+        caseId: __rspack_external_zod.z.string().optional()
+    }))();
+const miniappTestArtifactSchema = _miniappTestArtifactSchema;
+const _miniappTestArtifactPolicySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        trace: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_OFF',
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_FAILURE_ONLY',
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_ALWAYS'
+        ]),
+        screenshots: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_OFF',
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_FAILURE_ONLY',
+            'MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_ALWAYS'
+        ]),
+        maxBytes: __rspack_external_zod.z.number().optional()
+    }).strict())();
+const miniappTestArtifactPolicySchema = _miniappTestArtifactPolicySchema;
+const _miniappTestCapabilityWaiverSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        capability: __rspack_external_zod.z.string(),
+        reason: __rspack_external_zod.z.string(),
+        issue: __rspack_external_zod.z.string().optional(),
+        expiresAt: __rspack_external_zod.z.string().optional()
+    }).strict())();
+const miniappTestCapabilityWaiverSchema = _miniappTestCapabilityWaiverSchema;
+const _miniappTestCapturedHttpRequestsControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('captured-http-requests'),
+        captures: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpCapturesSchema)
+    }).strict())();
+const miniappTestCapturedHttpRequestsControlReceiptSchema = _miniappTestCapturedHttpRequestsControlReceiptSchema;
+const _miniappTestCapturedHttpRequestsControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('captured-http-requests')
+    }).strict())();
+const miniappTestCapturedHttpRequestsControlRequestSchema = _miniappTestCapturedHttpRequestsControlRequestSchema;
+const _miniappTestCountsSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        testFiles: __rspack_external_zod.z.number(),
+        failedFiles: __rspack_external_zod.z.number(),
+        tests: __rspack_external_zod.z.number(),
+        passedTests: __rspack_external_zod.z.number(),
+        failedTests: __rspack_external_zod.z.number(),
+        skippedTests: __rspack_external_zod.z.number(),
+        todoTests: __rspack_external_zod.z.number()
+    }))();
+const miniappTestCountsSchema = _miniappTestCountsSchema;
+const _miniappTestDriverCdpTargetSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        targetId: __rspack_external_zod.z.string(),
+        browserContextId: __rspack_external_zod.z.string().optional(),
+        targetType: __rspack_external_zod.z.string(),
+        pageUrl: __rspack_external_zod.z.string(),
+        surfaceSelector: __rspack_external_zod.z.string(),
+        surfaceAssetOrigin: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestDriverCdpTargetSchema = _miniappTestDriverCdpTargetSchema;
+const _miniappTestDriverDigestsSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        sourceSha256: __rspack_external_zod.z.string(),
+        testBundleSha256: __rspack_external_zod.z.string(),
+        descriptorSha256: __rspack_external_zod.z.string(),
+        fixtureSha256: __rspack_external_zod.z.string().optional(),
+        policySha256: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestDriverDigestsSchema = _miniappTestDriverDigestsSchema;
+const _miniappTestDriverMatrixEntrySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        entryId: __rspack_external_zod.z.string(),
+        target: __rspack_external_zod.z.string(),
+        surfaceId: __rspack_external_zod.z.string(),
+        mode: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_MODE_SURFACE',
+            'MINIAPP_TEST_MODE_LIVE_TAP'
+        ]),
+        presentation: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_PRESENTATION_HEADLESS',
+            'MINIAPP_TEST_PRESENTATION_VISIBLE'
+        ]),
+        dataScope: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_DATA_SCOPE_FIXTURE',
+            'MINIAPP_TEST_DATA_SCOPE_SELECTED_CHANNEL'
+        ]),
+        selectedChannelId: __rspack_external_zod.z.string().optional(),
+        permissionScenario: __rspack_external_zod.z.string(),
+        fixtureVersion: __rspack_external_zod.z.string().optional(),
+        profileId: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestDriverMatrixEntrySchema = _miniappTestDriverMatrixEntrySchema;
+const _miniappTestDriverProtocolSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        major: __rspack_external_zod.z.number(),
+        minor: __rspack_external_zod.z.number(),
+        features: __rspack_external_zod.z.array(__rspack_external_zod.z.string())
+    }).strict())();
+const miniappTestDriverProtocolSchema = _miniappTestDriverProtocolSchema;
+const _miniappTestDriverSessionSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        protocol: __rspack_external_zod.z.lazy(()=>miniappTestDriverProtocolSchema),
+        runId: __rspack_external_zod.z.string(),
+        runNonce: __rspack_external_zod.z.string(),
+        expiresAt: __rspack_external_zod.z.string(),
+        workspaceId: __rspack_external_zod.z.string(),
+        channelId: __rspack_external_zod.z.string(),
+        packageId: __rspack_external_zod.z.string(),
+        installationId: __rspack_external_zod.z.string(),
+        bindingId: __rspack_external_zod.z.string(),
+        releaseDigest: __rspack_external_zod.z.string().optional(),
+        localGeneration: __rspack_external_zod.z.number().optional(),
+        matrixEntry: __rspack_external_zod.z.lazy(()=>miniappTestDriverMatrixEntrySchema),
+        seed: __rspack_external_zod.z.number(),
+        versions: __rspack_external_zod.z.lazy(()=>miniappTestDriverVersionsSchema),
+        digests: __rspack_external_zod.z.lazy(()=>miniappTestDriverDigestsSchema),
+        cdpTarget: __rspack_external_zod.z.lazy(()=>miniappTestDriverCdpTargetSchema),
+        policy: __rspack_external_zod.z.lazy(()=>miniappTestPolicySchema),
+        cdpEndpoint: __rspack_external_zod.z.string(),
+        cdpAuthorization: __rspack_external_zod.z.string(),
+        artifactDirectory: __rspack_external_zod.z.string(),
+        environment: __rspack_external_zod.z.lazy(()=>miniappTestEnvironmentSchema),
+        artifacts: __rspack_external_zod.z.lazy(()=>miniappTestArtifactPolicySchema)
+    }).strict())();
+const miniappTestDriverSessionSchema = _miniappTestDriverSessionSchema;
+const _miniappTestDriverVersionsSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        hostVersion: __rspack_external_zod.z.string(),
+        hostContractVersion: __rspack_external_zod.z.string(),
+        adapterPackage: __rspack_external_zod.z.string(),
+        adapterVersion: __rspack_external_zod.z.string(),
+        runnerName: __rspack_external_zod.z.string(),
+        runnerVersion: __rspack_external_zod.z.string(),
+        nodeVersion: __rspack_external_zod.z.string(),
+        playwrightVersion: __rspack_external_zod.z.string(),
+        browserEngine: __rspack_external_zod.z.string(),
+        browserVersion: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestDriverVersionsSchema = _miniappTestDriverVersionsSchema;
+const _miniappTestEmitHostEventControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('emit-host-event'),
+        delivered: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestEmitHostEventControlReceiptSchema = _miniappTestEmitHostEventControlReceiptSchema;
+const _miniappTestEmitHostEventControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('emit-host-event'),
+        event: __rspack_external_zod.z.string(),
+        payload: jsonValueSchema.optional()
+    }).strict())();
+const miniappTestEmitHostEventControlRequestSchema = _miniappTestEmitHostEventControlRequestSchema;
+const _miniappTestEnvironmentSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        viewport: __rspack_external_zod.z.lazy(()=>miniappTestViewportSchema),
+        locale: __rspack_external_zod.z.string(),
+        timezone: __rspack_external_zod.z.string(),
+        theme: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_THEME_LIGHT',
+            'MINIAPP_TEST_THEME_DARK'
+        ]),
+        reducedMotion: __rspack_external_zod.z.boolean(),
+        seed: __rspack_external_zod.z.number(),
+        fixedNow: __rspack_external_zod.z.string().optional()
+    }).strict())();
+const miniappTestEnvironmentSchema = _miniappTestEnvironmentSchema;
+const _miniappTestExecutionSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        mode: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_MODE_SURFACE',
+            'MINIAPP_TEST_MODE_LIVE_TAP'
+        ]),
+        presentation: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_PRESENTATION_HEADLESS',
+            'MINIAPP_TEST_PRESENTATION_VISIBLE'
+        ]),
+        dataScope: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_DATA_SCOPE_FIXTURE',
+            'MINIAPP_TEST_DATA_SCOPE_SELECTED_CHANNEL'
+        ]),
+        runner: __rspack_external_zod.z.string(),
+        runnerVersion: __rspack_external_zod.z.string(),
+        nodeVersion: __rspack_external_zod.z.string(),
+        browserEngine: __rspack_external_zod.z.string(),
+        browserVersion: __rspack_external_zod.z.string(),
+        tapVersion: __rspack_external_zod.z.string(),
+        hostContractVersion: __rspack_external_zod.z.string(),
+        surfaceId: __rspack_external_zod.z.string(),
+        selectedChannelId: __rspack_external_zod.z.string().optional(),
+        fixtureVersion: __rspack_external_zod.z.string().optional()
+    }))();
+const miniappTestExecutionSchema = _miniappTestExecutionSchema;
+const _miniappTestFixtureChannelSeedSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        roomId: __rspack_external_zod.z.string(),
+        title: __rspack_external_zod.z.string(),
+        archived: __rspack_external_zod.z.boolean().optional(),
+        createdAt: __rspack_external_zod.z.number().optional(),
+        updatedAt: __rspack_external_zod.z.number().optional(),
+        messages: __rspack_external_zod.z.array(jsonValueSchema).default([]),
+        specialistIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([])
+    }).strict())();
+const miniappTestFixtureChannelSeedSchema = _miniappTestFixtureChannelSeedSchema;
+const _miniappTestFixtureChannelStateSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        roomId: __rspack_external_zod.z.string(),
+        title: __rspack_external_zod.z.string(),
+        archived: __rspack_external_zod.z.boolean(),
+        createdAt: __rspack_external_zod.z.number(),
+        updatedAt: __rspack_external_zod.z.number(),
+        messages: __rspack_external_zod.z.array(jsonValueSchema),
+        specialistIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string())
+    }).strict())();
+const miniappTestFixtureChannelStateSchema = _miniappTestFixtureChannelStateSchema;
+const _miniappTestFixtureCheckpointSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        installationId: __rspack_external_zod.z.string(),
+        releaseId: __rspack_external_zod.z.string(),
+        runtimeSlot: __rspack_external_zod.z.string(),
+        checkpointReference: __rspack_external_zod.z.string(),
+        value: jsonValueSchema
+    }).strict())();
+const miniappTestFixtureCheckpointSchema = _miniappTestFixtureCheckpointSchema;
+const _miniappTestFixtureHttpCaptureSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        sequence: __rspack_external_zod.z.number(),
+        matched: __rspack_external_zod.z.boolean(),
+        request: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpRequestSchema),
+        credentialRef: __rspack_external_zod.z.string().optional(),
+        auth: __rspack_external_zod.z.literal('github').optional()
+    }).strict())();
+const miniappTestFixtureHttpCaptureSchema = _miniappTestFixtureHttpCaptureSchema;
+const _miniappTestFixtureHttpCapturesSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        requests: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpCaptureSchema)),
+        dropped: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestFixtureHttpCapturesSchema = _miniappTestFixtureHttpCapturesSchema;
+const _miniappTestFixtureHttpHeaderSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        name: __rspack_external_zod.z.string(),
+        value: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestFixtureHttpHeaderSchema = _miniappTestFixtureHttpHeaderSchema;
+const _miniappTestFixtureHttpHeaderInputSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        name: __rspack_external_zod.z.string(),
+        value: __rspack_external_zod.z.string(),
+        enabled: __rspack_external_zod.z.boolean().optional()
+    }).strict())();
+const miniappTestFixtureHttpHeaderInputSchema = _miniappTestFixtureHttpHeaderInputSchema;
+const _miniappTestFixtureHttpRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        method: __rspack_external_zod.z.string(),
+        url: __rspack_external_zod.z.string(),
+        query: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpHeaderInputSchema)).default([]),
+        headers: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpHeaderInputSchema)).default([]),
+        body: __rspack_external_zod.z.string().optional(),
+        timeoutMs: __rspack_external_zod.z.number().optional(),
+        responseBodyLimitBytes: __rspack_external_zod.z.number().optional(),
+        followRedirects: __rspack_external_zod.z.boolean().optional()
+    }).strict())();
+const miniappTestFixtureHttpRequestSchema = _miniappTestFixtureHttpRequestSchema;
+const _miniappTestFixtureHttpResponseSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        finalUrl: __rspack_external_zod.z.string(),
+        status: __rspack_external_zod.z.number(),
+        statusText: __rspack_external_zod.z.string(),
+        headers: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpHeaderSchema)),
+        bodyText: __rspack_external_zod.z.string().optional(),
+        bodyBase64: __rspack_external_zod.z.string().optional(),
+        bodyKind: __rspack_external_zod.z["enum"]([
+            'text',
+            'binary'
+        ]),
+        bodyTruncated: __rspack_external_zod.z.boolean(),
+        sizeBytes: __rspack_external_zod.z.number(),
+        elapsedMs: __rspack_external_zod.z.number(),
+        contentType: __rspack_external_zod.z.string().optional()
+    }).strict())();
+const miniappTestFixtureHttpResponseSchema = _miniappTestFixtureHttpResponseSchema;
+const _miniappTestFixtureHttpScriptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        request: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpRequestSchema),
+        credentialRef: __rspack_external_zod.z.string().optional(),
+        auth: __rspack_external_zod.z.literal('github').optional(),
+        response: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpResponseSchema),
+        repeat: __rspack_external_zod.z.number().optional()
+    }).strict())();
+const miniappTestFixtureHttpScriptSchema = _miniappTestFixtureHttpScriptSchema;
+const _miniappTestFixtureHttpScriptStateSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        request: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpRequestSchema),
+        credentialRef: __rspack_external_zod.z.string().optional(),
+        auth: __rspack_external_zod.z.literal('github').optional(),
+        response: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpResponseSchema),
+        repeat: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestFixtureHttpScriptStateSchema = _miniappTestFixtureHttpScriptStateSchema;
+const _miniappTestFixtureLedgerSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        entries: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureLedgerEntrySchema)),
+        dropped: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestFixtureLedgerSchema = _miniappTestFixtureLedgerSchema;
+const _miniappTestFixtureLedgerEntrySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        sequence: __rspack_external_zod.z.number(),
+        fixtureGeneration: __rspack_external_zod.z.number(),
+        timestampMs: __rspack_external_zod.z.number(),
+        kind: __rspack_external_zod.z["enum"]([
+            'event',
+            'host-action',
+            'native',
+            'platform'
+        ]),
+        operation: __rspack_external_zod.z.string(),
+        detail: jsonValueSchema
+    }).strict())();
+const miniappTestFixtureLedgerEntrySchema = _miniappTestFixtureLedgerEntrySchema;
+const _miniappTestFixturePresenceSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        packageId: __rspack_external_zod.z.string(),
+        namespace: __rspack_external_zod.z.string(),
+        room: __rspack_external_zod.z.string(),
+        selfParticipantId: __rspack_external_zod.z.string(),
+        participants: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixturePresenceParticipantSchema))
+    }).strict())();
+const miniappTestFixturePresenceSchema = _miniappTestFixturePresenceSchema;
+const _miniappTestFixturePresenceParticipantSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        participantId: __rspack_external_zod.z.string(),
+        displayName: __rspack_external_zod.z.string(),
+        state: jsonValueSchema,
+        updatedAtMs: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestFixturePresenceParticipantSchema = _miniappTestFixturePresenceParticipantSchema;
+const _miniappTestFixtureProjectSeedSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        id: __rspack_external_zod.z.string(),
+        name: __rspack_external_zod.z.string(),
+        discoverable: __rspack_external_zod.z.boolean().optional(),
+        channelIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        archivedChannelIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([])
+    }).strict())();
+const miniappTestFixtureProjectSeedSchema = _miniappTestFixtureProjectSeedSchema;
+const _miniappTestFixtureProjectStateSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        id: __rspack_external_zod.z.string(),
+        name: __rspack_external_zod.z.string(),
+        discoverable: __rspack_external_zod.z.boolean(),
+        channelIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string()),
+        archivedChannelIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string())
+    }).strict())();
+const miniappTestFixtureProjectStateSchema = _miniappTestFixtureProjectStateSchema;
+const _miniappTestFixtureSeedSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        projects: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureProjectSeedSchema)).default([]),
+        channels: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureChannelSeedSchema)).default([]),
+        workflows: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureWorkflowSchema)).default([]),
+        vfsFiles: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureVfsFileSchema)).default([]),
+        vfsDirectories: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureVfsDirectorySchema)).default([]),
+        storage: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureStorageEntrySchema)).default([]),
+        presence: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixturePresenceSchema)).default([]),
+        checkpoints: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureCheckpointSchema)).default([]),
+        specialists: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureSpecialistSchema)).default([]),
+        httpScripts: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpScriptSchema)).default([])
+    }).strict())();
+const miniappTestFixtureSeedSchema = _miniappTestFixtureSeedSchema;
+const _miniappTestFixtureSnapshotSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        fixtureVersion: __rspack_external_zod.z.string(),
+        workspaceId: __rspack_external_zod.z.string(),
+        channelId: __rspack_external_zod.z.string(),
+        fixtureGeneration: __rspack_external_zod.z.number(),
+        fixtureDigest: __rspack_external_zod.z.string(),
+        clockTick: __rspack_external_zod.z.number(),
+        state: __rspack_external_zod.z.lazy(()=>miniappTestFixtureStateSchema)
+    }).strict())();
+const miniappTestFixtureSnapshotSchema = _miniappTestFixtureSnapshotSchema;
+const _miniappTestFixtureSpecialistSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        id: __rspack_external_zod.z.string(),
+        value: jsonValueSchema
+    }).strict())();
+const miniappTestFixtureSpecialistSchema = _miniappTestFixtureSpecialistSchema;
+const _miniappTestFixtureStateSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        projects: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureProjectStateSchema)),
+        channels: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureChannelStateSchema)),
+        workflows: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureWorkflowSchema)),
+        vfsFiles: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureVfsFileSchema)),
+        vfsDirectories: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureVfsDirectorySchema)),
+        storage: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureStorageEntrySchema)),
+        presence: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixturePresenceSchema)),
+        checkpoints: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureCheckpointSchema)),
+        specialists: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureSpecialistSchema)),
+        httpScripts: __rspack_external_zod.z.array(__rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpScriptStateSchema))
+    }).strict())();
+const miniappTestFixtureStateSchema = _miniappTestFixtureStateSchema;
+const _miniappTestFixtureStorageEntrySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        workspaceId: __rspack_external_zod.z.string(),
+        packageId: __rspack_external_zod.z.string(),
+        namespace: __rspack_external_zod.z.string(),
+        key: __rspack_external_zod.z.string(),
+        revision: __rspack_external_zod.z.number(),
+        value: jsonValueSchema
+    }).strict())();
+const miniappTestFixtureStorageEntrySchema = _miniappTestFixtureStorageEntrySchema;
+const _miniappTestFixtureVfsDirectorySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        conversationId: __rspack_external_zod.z.string(),
+        path: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestFixtureVfsDirectorySchema = _miniappTestFixtureVfsDirectorySchema;
+const _miniappTestFixtureVfsFileSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        conversationId: __rspack_external_zod.z.string(),
+        path: __rspack_external_zod.z.string(),
+        data: __rspack_external_zod.z.array(__rspack_external_zod.z.number())
+    }).strict())();
+const miniappTestFixtureVfsFileSchema = _miniappTestFixtureVfsFileSchema;
+const _miniappTestFixtureWorkflowSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        workflowId: __rspack_external_zod.z.string(),
+        name: __rspack_external_zod.z.string(),
+        result: jsonValueSchema,
+        type: __rspack_external_zod.z.string().optional(),
+        createdAt: __rspack_external_zod.z.number().optional(),
+        updatedAt: __rspack_external_zod.z.number().optional()
+    }).strict())();
+const miniappTestFixtureWorkflowSchema = _miniappTestFixtureWorkflowSchema;
+const _miniappTestMatrixEntrySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        id: __rspack_external_zod.z.string(),
+        profile: __rspack_external_zod.z.string(),
+        testMatch: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        capabilities: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([])
+    }).strict())();
+const miniappTestMatrixEntrySchema = _miniappTestMatrixEntrySchema;
+const _miniappTestPolicySchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        permissionScenario: __rspack_external_zod.z.string(),
+        allowedNetworkOrigins: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        effectGrants: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        credentialAliases: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        artifactRedactionPolicy: __rspack_external_zod.z.string(),
+        timeoutSeconds: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestPolicySchema = _miniappTestPolicySchema;
+const _miniappTestProfileSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        surface: __rspack_external_zod.z.string(),
+        target: __rspack_external_zod.z.string(),
+        mode: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_MODE_SURFACE',
+            'MINIAPP_TEST_MODE_LIVE_TAP'
+        ]),
+        permissionScenario: __rspack_external_zod.z.string(),
+        deniedActions: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        fixtureFiles: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        httpRouteFiles: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        requiredOrigins: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        requiredEffects: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        credentialSlots: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        environment: __rspack_external_zod.z.lazy(()=>miniappTestEnvironmentSchema),
+        artifacts: __rspack_external_zod.z.lazy(()=>miniappTestArtifactPolicySchema)
+    }).strict())();
+const miniappTestProfileSchema = _miniappTestProfileSchema;
+const _miniappTestReadLedgerControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('read-ledger'),
+        ledger: __rspack_external_zod.z.lazy(()=>miniappTestFixtureLedgerSchema)
+    }).strict())();
+const miniappTestReadLedgerControlReceiptSchema = _miniappTestReadLedgerControlReceiptSchema;
+const _miniappTestReadLedgerControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('read-ledger')
+    }).strict())();
+const miniappTestReadLedgerControlRequestSchema = _miniappTestReadLedgerControlRequestSchema;
+const _miniappTestRemountSurfaceControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('remount-surface'),
+        mode: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_MODE_SURFACE',
+            'MINIAPP_TEST_MODE_LIVE_TAP'
+        ]),
+        surfaceGeneration: __rspack_external_zod.z.number(),
+        fixtureGeneration: __rspack_external_zod.z.number().optional(),
+        fixtureDigest: __rspack_external_zod.z.string().optional(),
+        instanceId: __rspack_external_zod.z.string(),
+        documentId: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestRemountSurfaceControlReceiptSchema = _miniappTestRemountSurfaceControlReceiptSchema;
+const _miniappTestRemountSurfaceControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('remount-surface')
+    }).strict())();
+const miniappTestRemountSurfaceControlRequestSchema = _miniappTestRemountSurfaceControlRequestSchema;
+const _miniappTestResetFixtureControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('reset-fixture'),
+        mode: __rspack_external_zod.z["enum"]([
+            'MINIAPP_TEST_MODE_SURFACE',
+            'MINIAPP_TEST_MODE_LIVE_TAP'
+        ]),
+        surfaceGeneration: __rspack_external_zod.z.number(),
+        fixtureGeneration: __rspack_external_zod.z.number().optional(),
+        fixtureDigest: __rspack_external_zod.z.string().optional(),
+        instanceId: __rspack_external_zod.z.string(),
+        documentId: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestResetFixtureControlReceiptSchema = _miniappTestResetFixtureControlReceiptSchema;
+const _miniappTestResetFixtureControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('reset-fixture')
+    }).strict())();
+const miniappTestResetFixtureControlRequestSchema = _miniappTestResetFixtureControlRequestSchema;
+const _miniappTestScriptHttpControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal("script-http"),
+        fixtureGeneration: __rspack_external_zod.z.number(),
+        scriptedRequests: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestScriptHttpControlReceiptSchema = _miniappTestScriptHttpControlReceiptSchema;
+const _miniappTestScriptHttpControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal("script-http"),
+        script: __rspack_external_zod.z.lazy(()=>miniappTestFixtureHttpScriptSchema)
+    }).strict())();
+const miniappTestScriptHttpControlRequestSchema = _miniappTestScriptHttpControlRequestSchema;
+const _miniappTestSeedFixtureControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('seed-fixture'),
+        fixtureGeneration: __rspack_external_zod.z.number(),
+        fixtureDigest: __rspack_external_zod.z.string(),
+        surfaceGeneration: __rspack_external_zod.z.number(),
+        instanceId: __rspack_external_zod.z.string(),
+        documentId: __rspack_external_zod.z.string()
+    }).strict())();
+const miniappTestSeedFixtureControlReceiptSchema = _miniappTestSeedFixtureControlReceiptSchema;
+const _miniappTestSeedFixtureControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('seed-fixture'),
+        seed: __rspack_external_zod.z.lazy(()=>miniappTestFixtureSeedSchema)
+    }).strict())();
+const miniappTestSeedFixtureControlRequestSchema = _miniappTestSeedFixtureControlRequestSchema;
+const _miniappTestSelectionSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        projectNames: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        filePaths: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        caseIds: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        nameFilter: __rspack_external_zod.z.string().optional(),
+        affectedSourcePaths: __rspack_external_zod.z.array(__rspack_external_zod.z.string()).default([]),
+        changedOnly: __rspack_external_zod.z.boolean()
+    }))();
+const miniappTestSelectionSchema = _miniappTestSelectionSchema;
+const _miniappTestSnapshotFixtureControlReceiptSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('snapshot-fixture'),
+        snapshot: __rspack_external_zod.z.lazy(()=>miniappTestFixtureSnapshotSchema)
+    }).strict())();
+const miniappTestSnapshotFixtureControlReceiptSchema = _miniappTestSnapshotFixtureControlReceiptSchema;
+const _miniappTestSnapshotFixtureControlRequestSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        schemaVersion: __rspack_external_zod.z.literal(1),
+        requestId: __rspack_external_zod.z.string(),
+        runId: __rspack_external_zod.z.string(),
+        operation: __rspack_external_zod.z.literal('snapshot-fixture')
+    }).strict())();
+const miniappTestSnapshotFixtureControlRequestSchema = _miniappTestSnapshotFixtureControlRequestSchema;
+const _miniappTestViewportSchema = /* @__PURE__ */ (()=>__rspack_external_zod.z.object({
+        width: __rspack_external_zod.z.number(),
+        height: __rspack_external_zod.z.number()
+    }).strict())();
+const miniappTestViewportSchema = _miniappTestViewportSchema;
+const TAP_DRIVER_PROTOCOL_MAJOR = 1;
+const TAP_DRIVER_PROTOCOL_MINOR = 0;
+const TAP_DRIVER_FEATURE_EXACT_CDP_TARGET = 'exact-cdp-target-v1';
+const TAP_DRIVER_FEATURE_FIXTURE_CONTROL = 'fixture-control-v1';
+const TAP_DRIVER_RUN_QUERY = 'tapMiniappTestRun';
+const TAP_DRIVER_NONCE_QUERY = 'tapMiniappTestNonce';
+const SDK_PACKAGE = '@theaiplatform/miniapp-sdk';
+const SUPPORTED_FEATURES = new Set([
+    TAP_DRIVER_FEATURE_EXACT_CDP_TARGET,
+    TAP_DRIVER_FEATURE_FIXTURE_CONTROL
+]);
+const REQUIRED_FEATURES = [
+    TAP_DRIVER_FEATURE_EXACT_CDP_TARGET,
+    TAP_DRIVER_FEATURE_FIXTURE_CONTROL
+];
+const LOWERCASE_SHA256 = /^[0-9a-f]{64}$/u;
+const CANONICAL_DESCRIPTOR_ID = /^[a-z0-9][a-z0-9._:-]*$/u;
+const SHA256_SRI = /^sha256-([A-Za-z0-9+/]{43}=)$/u;
+const RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/u;
+const CANONICAL_UTC_INSTANT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/u;
+const MAX_UINT32 = 0xffffffff;
+const HTTP_PROTOCOLS = new Set([
+    'http:',
+    'https:'
+]);
+const MAX_CONTROL_JSON_DEPTH = 32;
+const MAX_CONTROL_JSON_NODES = 50000;
+const MAX_FIXTURE_SEED_BYTES = 8388608;
+const MAX_FIXTURE_HTTP_SCRIPT_BYTES = 1048576;
+const MAX_CONTROL_RESULT_BYTES = 8388608;
+const MAX_HOST_EVENT_PAYLOAD_BYTES = 61440;
+const MAX_FIXTURE_COLLECTION_ITEMS = 256;
+const MAX_FIXTURE_HTTP_CAPTURES = 1024;
+const MAX_FIXTURE_LEDGER_ENTRIES = 4096;
+const MAX_FIXTURE_HTTP_REPEATS = 100;
+const installedManifestSchema = __rspack_external_zod.z.object({
+    name: __rspack_external_zod.z.literal(SDK_PACKAGE),
+    version: __rspack_external_zod.z.string().trim().min(1)
 });
-let sessionPromise;
-let browserPromise;
-function parseTapMiniappTestSession(value) {
-    return sessionSchema.parse(value);
+const cdpTargetInfoResponseSchema = __rspack_external_zod.z.object({
+    targetInfo: __rspack_external_zod.z.object({
+        browserContextId: __rspack_external_zod.z.string().optional(),
+        targetId: __rspack_external_zod.z.string(),
+        type: __rspack_external_zod.z.string(),
+        url: __rspack_external_zod.z.string()
+    }).passthrough()
+}).passthrough();
+function contractError(message) {
+    return new Error(`Invalid TAP miniapp driver session: ${message}`);
 }
-async function loadSession() {
-    sessionPromise ??= (async ()=>{
-        const sessionPath = process.env[SESSION_ENV]?.trim();
-        if (!sessionPath) throw new Error(`${SESSION_ENV} is missing. Start this suite from The AI Platform Miniapp Test Lab.`);
-        const raw = await (0, __rspack_external_node_fs_promises_3b710708.readFile)(sessionPath, 'utf8');
-        return parseTapMiniappTestSession(JSON.parse(raw));
-    })();
-    return sessionPromise;
+function readInstalledSdkIdentity() {
+    const manifestUrl = new URL('../../package.json', import.meta.url);
+    let value;
+    try {
+        value = JSON.parse((0, __rspack_external_node_fs_1b05aee1.readFileSync)(manifestUrl, 'utf8'));
+    } catch (error) {
+        throw new Error(`Unable to read the installed ${SDK_PACKAGE} package manifest: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return Object.freeze(installedManifestSchema.parse(value));
+}
+const installedSdkIdentity = readInstalledSdkIdentity();
+function requireTrimmed(value, label, maximumLength = 512) {
+    if (0 === value.length || value.length > maximumLength || value.trim() !== value) throw contractError(`${label} must be a non-empty trimmed value no longer than ${maximumLength} characters`);
+    return value;
+}
+function requireCanonicalDescriptorId(value, label) {
+    requireTrimmed(value, label, 128);
+    if (new TextEncoder().encode(value).byteLength > 128 || !CANONICAL_DESCRIPTOR_ID.test(value) || LOWERCASE_SHA256.test(value)) throw contractError(`${label} must be a lowercase canonical descriptor id no longer than 128 bytes`);
+    return value;
 }
-function selectPage(context, session) {
-    const candidates = context.pages().filter((candidate)=>candidate.url().startsWith(session.pageUrlPrefix));
-    if (1 !== candidates.length) throw new Error(`TAP Browser Driver exposed ${candidates.length} matching pages for run ${session.runId}; expected exactly one.`);
-    const page = candidates[0];
-    if (!page) throw new Error('TAP Browser Driver page selection failed');
-    return page;
+function validateEnvironment(session) {
+    const environment = session.environment;
+    const width = requireUnsignedInteger(environment.viewport.width, 'environment.viewport.width', 8192);
+    const height = requireUnsignedInteger(environment.viewport.height, 'environment.viewport.height', 8192);
+    if (width < 320 || height < 200) throw contractError('environment viewport must be at least 320 by 200 pixels');
+    const locale = requireTrimmed(environment.locale, 'environment.locale', 64);
+    if (!/^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$/u.test(locale)) throw contractError('environment.locale must be a canonical locale tag');
+    const timezone = requireTrimmed(environment.timezone, 'environment.timezone', 128);
+    try {
+        new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone
+        }).format();
+    } catch  {
+        throw contractError('environment.timezone must be an IANA time zone');
+    }
+    const seed = requireUnsignedInteger(environment.seed, 'environment.seed', MAX_UINT32);
+    if (requireUnsignedInteger(session.seed, 'seed', MAX_UINT32) !== seed) throw contractError('seed must match environment.seed');
+    const fixedNow = void 0 === environment.fixedNow ? void 0 : requireTrimmed(environment.fixedNow, 'environment.fixedNow', 64);
+    if (void 0 !== fixedNow && (!CANONICAL_UTC_INSTANT.test(fixedNow) || !Number.isFinite(Date.parse(fixedNow)))) throw contractError('environment.fixedNow must be a canonical UTC RFC 3339 instant');
+    return Object.freeze({
+        viewport: Object.freeze({
+            width,
+            height
+        }),
+        locale,
+        timezone,
+        theme: 'MINIAPP_TEST_THEME_LIGHT' === environment.theme ? 'light' : 'dark',
+        reducedMotion: environment.reducedMotion,
+        seed,
+        ...void 0 === fixedNow ? {} : {
+            fixedNow
+        }
+    });
+}
+function artifactCapturePolicy(value) {
+    if ('MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_OFF' === value) return 'off';
+    if ('MINIAPP_TEST_ARTIFACT_CAPTURE_POLICY_ALWAYS' === value) return 'always';
+    return 'failure-only';
+}
+function validateArtifacts(session) {
+    const maximum = session.artifacts.maxBytes;
+    if (void 0 !== maximum) {
+        const normalized = requireUnsignedInteger(maximum, 'artifacts.maxBytes', 67108864);
+        if (normalized < 1024) throw contractError('artifacts.maxBytes must be at least 1024');
+    }
+    return Object.freeze({
+        trace: artifactCapturePolicy(session.artifacts.trace),
+        screenshots: artifactCapturePolicy(session.artifacts.screenshots),
+        ...void 0 === maximum ? {} : {
+            maxBytes: maximum
+        }
+    });
+}
+function requireSha256(value, label) {
+    if (!LOWERCASE_SHA256.test(value)) throw contractError(`${label} must be a lowercase 64-character SHA-256 digest`);
+    return value;
+}
+function requireOptionalSha256(value, label) {
+    return void 0 === value ? void 0 : requireSha256(value, label);
+}
+function requireSha256Sri(value, label) {
+    const encoded = SHA256_SRI.exec(value)?.[1];
+    if (!encoded) throw contractError(`${label} must be a canonical sha256-<base64> SRI digest`);
+    const bytes = Buffer.from(encoded, 'base64');
+    if (32 !== bytes.byteLength || bytes.toString('base64') !== encoded) throw contractError(`${label} must be a canonical sha256-<base64> SRI digest`);
+    return value;
+}
+function requireHttpUrl(value, label) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    } catch  {
+        throw contractError(`${label} must be an absolute URL`);
+    }
+    if (!HTTP_PROTOCOLS.has(parsed.protocol)) throw contractError(`${label} must use HTTP or HTTPS`);
+    return parsed;
 }
-async function emitHostEvent(page, session, event, payload) {
-    if (!event.startsWith('tap.') || event.length > 160 || event.trim() !== event) throw new Error('TAP host events must be bounded, trimmed tap.* event names.');
-    await page.evaluate(({ controlEvent, event, payload, runId })=>{
+function requireHttpOrigin(value, label) {
+    const parsed = requireHttpUrl(value, label);
+    if (parsed.username || parsed.password || '/' !== parsed.pathname || parsed.search || parsed.hash) throw contractError(`${label} must be an origin without a path or secrets`);
+    return parsed.origin;
+}
+function isLoopbackHostname(hostname) {
+    const unwrapped = hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+    if ('localhost' === unwrapped.toLocaleLowerCase('en-US') || '::1' === unwrapped || '0:0:0:0:0:0:0:1' === unwrapped) return true;
+    const octets = unwrapped.split('.');
+    return 4 === octets.length && '127' === octets[0] && octets.every((octet)=>/^(?:0|[1-9][0-9]{0,2})$/u.test(octet) && Number(octet) <= 255);
+}
+function requireLoopbackCdpEndpoint(value) {
+    let parsed;
+    try {
+        parsed = new URL(value);
+    } catch  {
+        throw contractError('cdpEndpoint must be an absolute URL');
+    }
+    if (!new Set([
+        'http:',
+        'ws:'
+    ]).has(parsed.protocol)) throw contractError('cdpEndpoint must use HTTP or WebSocket');
+    if (!isLoopbackHostname(parsed.hostname) || parsed.username || parsed.password || parsed.search || parsed.hash) throw contractError('cdpEndpoint must be a credential-free loopback-only URL');
+    return parsed.toString();
+}
+function requireUnsignedInteger(value, label, maximum) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) throw contractError(`${label} must be an unsigned integer no greater than ${maximum}`);
+    return value;
+}
+function requireStringList(values, label, maximumEntries) {
+    if (values.length > maximumEntries) throw contractError(`${label} may contain at most ${maximumEntries} items`);
+    const normalized = values.map((value, index)=>requireTrimmed(value, `${label}[${index}]`, 256));
+    if (new Set(normalized).size !== normalized.length) throw contractError(`${label} must not contain duplicates`);
+    return Object.freeze(normalized);
+}
+function validateProtocol(session) {
+    if (session.protocol.major !== TAP_DRIVER_PROTOCOL_MAJOR) throw contractError(`protocol major ${session.protocol.major} is incompatible with supported major ${TAP_DRIVER_PROTOCOL_MAJOR}`);
+    requireUnsignedInteger(session.protocol.minor, 'protocol.minor', MAX_UINT32);
+    if (session.protocol.minor > TAP_DRIVER_PROTOCOL_MINOR) throw contractError(`protocol minor ${session.protocol.minor} is newer than supported minor ${TAP_DRIVER_PROTOCOL_MINOR}`);
+    if (0 === session.protocol.features.length) throw contractError('protocol.features must contain a negotiated feature');
+    const features = requireStringList(session.protocol.features, 'protocol.features', 32);
+    for (const feature of features)if (!SUPPORTED_FEATURES.has(feature)) throw contractError(`protocol feature ${feature} is not supported`);
+    for (const requiredFeature of REQUIRED_FEATURES)if (!features.includes(requiredFeature)) throw contractError(`protocol feature ${requiredFeature} must be negotiated`);
+    return features;
+}
+function validateExpiry(expiresAt) {
+    if (!RFC3339.test(expiresAt)) throw contractError('expiresAt must be an RFC 3339 timestamp');
+    const expiresAtMs = Date.parse(expiresAt);
+    if (!Number.isFinite(expiresAtMs)) throw contractError('expiresAt must be a real timestamp');
+    if (expiresAtMs <= Date.now()) throw contractError('the driver session has expired');
+    return expiresAt;
+}
+function validateAdapter(session) {
+    if (session.versions.adapterPackage !== installedSdkIdentity.name) throw contractError(`adapter package ${session.versions.adapterPackage} does not match ${installedSdkIdentity.name}`);
+    if (session.versions.adapterVersion !== installedSdkIdentity.version) throw contractError(`adapter version ${session.versions.adapterVersion} does not match installed version ${installedSdkIdentity.version}`);
+    if ('rstest' !== session.versions.runnerName) throw contractError('versions.runnerName must be rstest');
+    for (const [label, value] of Object.entries(session.versions))requireTrimmed(value, `versions.${label}`, 256);
+    return {
+        adapterVersion: session.versions.adapterVersion,
+        browserEngine: session.versions.browserEngine,
+        browserVersion: session.versions.browserVersion,
+        hostContractVersion: session.versions.hostContractVersion,
+        hostVersion: session.versions.hostVersion,
+        nodeVersion: session.versions.nodeVersion,
+        playwrightVersion: session.versions.playwrightVersion,
+        runnerName: 'rstest',
+        runnerVersion: session.versions.runnerVersion
+    };
+}
+function validateMatrixAndFixture(session) {
+    const matrix = session.matrixEntry;
+    const fixtureDigest = requireOptionalSha256(session.digests.fixtureSha256, 'digests.fixtureSha256');
+    if (matrix.permissionScenario !== session.policy.permissionScenario) throw contractError('matrixEntry.permissionScenario must match policy.permissionScenario');
+    const presentation = 'MINIAPP_TEST_PRESENTATION_HEADLESS' === matrix.presentation ? 'headless' : 'visible';
+    if ('MINIAPP_TEST_MODE_SURFACE' === matrix.mode) {
+        if ('MINIAPP_TEST_DATA_SCOPE_FIXTURE' !== matrix.dataScope) throw contractError('Surface mode requires fixture data scope');
+        if (!fixtureDigest) throw contractError('Surface mode requires digests.fixtureSha256');
+        const fixtureVersion = requireTrimmed(matrix.fixtureVersion ?? '', 'matrixEntry.fixtureVersion', 256);
+        if (void 0 !== matrix.selectedChannelId) throw contractError('Surface mode must not declare matrixEntry.selectedChannelId');
+        return {
+            dataScope: 'fixture',
+            fixtureDigest,
+            fixtureVersion,
+            mode: 'surface',
+            presentation
+        };
+    }
+    if ('MINIAPP_TEST_DATA_SCOPE_SELECTED_CHANNEL' !== matrix.dataScope) throw contractError('Live TAP mode requires selected-channel data scope');
+    if (void 0 !== fixtureDigest || void 0 !== matrix.fixtureVersion) throw contractError('Live TAP mode must not declare fixtureVersion or fixtureSha256');
+    return {
+        dataScope: 'selected-channel',
+        mode: 'live-tap',
+        presentation,
+        selectedChannelId: requireTrimmed(matrix.selectedChannelId ?? '', 'matrixEntry.selectedChannelId')
+    };
+}
+function validateTarget(session, runId, runNonce) {
+    const target = session.cdpTarget;
+    if ('page' !== target.targetType) throw contractError('cdpTarget.targetType must be page');
+    const pageUrl = requireHttpUrl(target.pageUrl, 'cdpTarget.pageUrl');
+    if (pageUrl.searchParams.get(TAP_DRIVER_RUN_QUERY) !== runId) throw contractError(`cdpTarget.pageUrl must bind ${TAP_DRIVER_RUN_QUERY} to runId`);
+    if (pageUrl.searchParams.get(TAP_DRIVER_NONCE_QUERY) !== runNonce) throw contractError(`cdpTarget.pageUrl must bind ${TAP_DRIVER_NONCE_QUERY} to runNonce`);
+    return {
+        browserContextId: void 0 === target.browserContextId ? void 0 : requireTrimmed(target.browserContextId, 'cdpTarget.browserContextId'),
+        pageUrl: target.pageUrl,
+        surfaceAssetOrigin: requireHttpOrigin(target.surfaceAssetOrigin, 'cdpTarget.surfaceAssetOrigin'),
+        surfaceSelector: requireTrimmed(target.surfaceSelector, 'cdpTarget.surfaceSelector', 1024),
+        targetId: requireTrimmed(target.targetId, 'cdpTarget.targetId'),
+        targetType: 'page'
+    };
+}
+function parseValidatedTapMiniappTestSession(value) {
+    const session = miniappTestDriverSessionSchema.parse(value);
+    const features = validateProtocol(session);
+    const versions = validateAdapter(session);
+    const environment = validateEnvironment(session);
+    const artifacts = validateArtifacts(session);
+    const runId = requireTrimmed(session.runId, 'runId');
+    const runNonce = requireSha256(session.runNonce, 'runNonce');
+    const matrixAndFixture = validateMatrixAndFixture(session);
+    const target = validateTarget(session, runId, runNonce);
+    const releaseDigest = void 0 === session.releaseDigest ? void 0 : requireSha256Sri(session.releaseDigest, 'releaseDigest');
+    const localGeneration = void 0 === session.localGeneration ? void 0 : requireUnsignedInteger(session.localGeneration, 'localGeneration', Number.MAX_SAFE_INTEGER);
+    if (void 0 === releaseDigest === (void 0 === localGeneration)) throw contractError('exactly one of releaseDigest or localGeneration must be present');
+    const allowedNetworkOrigins = Object.freeze(session.policy.allowedNetworkOrigins.map((origin, index)=>requireHttpOrigin(origin, `policy.allowedNetworkOrigins[${index}]`)));
+    if (allowedNetworkOrigins.length > 128) throw contractError('policy.allowedNetworkOrigins may contain at most 128 items');
+    if (0 === requireUnsignedInteger(session.policy.timeoutSeconds, 'policy.timeoutSeconds', 86400)) throw contractError('policy.timeoutSeconds must be greater than zero');
+    return Object.freeze({
+        protocolMajor: session.protocol.major,
+        protocolMinor: session.protocol.minor,
+        features,
+        runId,
+        runNonce,
+        expiresAt: validateExpiry(session.expiresAt),
+        workspaceId: requireTrimmed(session.workspaceId, 'workspaceId'),
+        channelId: requireTrimmed(session.channelId, 'channelId'),
+        packageId: requireTrimmed(session.packageId, 'packageId'),
+        installationId: requireTrimmed(session.installationId, 'installationId'),
+        bindingId: requireTrimmed(session.bindingId, 'bindingId'),
+        releaseDigest,
+        localGeneration,
+        matrixEntryId: requireCanonicalDescriptorId(session.matrixEntry.entryId, 'matrixEntry.entryId'),
+        profileId: requireCanonicalDescriptorId(session.matrixEntry.profileId, 'matrixEntry.profileId'),
+        target: requireTrimmed(session.matrixEntry.target, 'matrixEntry.target'),
+        matrixTarget: requireTrimmed(session.matrixEntry.target, 'matrixEntry.target'),
+        ...matrixAndFixture,
+        permissionScenario: requireTrimmed(session.policy.permissionScenario, 'policy.permissionScenario'),
+        seed: environment.seed,
+        environment,
+        artifacts,
+        sourceDigest: requireSha256(session.digests.sourceSha256, 'digests.sourceSha256'),
+        testBundleDigest: requireSha256(session.digests.testBundleSha256, 'digests.testBundleSha256'),
+        descriptorDigest: requireSha256(session.digests.descriptorSha256, "digests.descriptorSha256"),
+        policyDigest: requireSha256(session.digests.policySha256, 'digests.policySha256'),
+        ...versions,
+        ...target,
+        surfaceId: requireTrimmed(session.matrixEntry.surfaceId, 'matrixEntry.surfaceId'),
+        cdpEndpoint: requireLoopbackCdpEndpoint(session.cdpEndpoint),
+        cdpAuthorization: requireTrimmed(session.cdpAuthorization, 'cdpAuthorization', 1024),
+        artifactDirectory: requireTrimmed(session.artifactDirectory, 'artifactDirectory', 4096),
+        allowedNetworkOrigins,
+        effectGrants: requireStringList(session.policy.effectGrants, 'policy.effectGrants', 128),
+        credentialAliases: requireStringList(session.policy.credentialAliases, 'policy.credentialAliases', 64)
+    });
+}
+async function connectValidatedTapMiniappTestSession(value, connect) {
+    const session = parseValidatedTapMiniappTestSession(value);
+    const connection = await connect(session.cdpEndpoint, {
+        headers: {
+            authorization: `Bearer ${session.cdpAuthorization}`,
+            'x-tap-miniapp-test-run': session.runId
+        }
+    });
+    return Object.freeze({
+        connection,
+        session
+    });
+}
+function requireBoundedJson(value, label, maximumBytes) {
+    const active = new WeakSet();
+    let nodes = 0;
+    let serializedBytes = 0;
+    const append = (serialized)=>{
+        serializedBytes += Buffer.byteLength(serialized, 'utf8');
+        if (serializedBytes > maximumBytes) throw contractError(`${label} must serialize to no more than ${maximumBytes} bytes`);
+    };
+    const visit = (candidate, depth)=>{
+        nodes += 1;
+        if (nodes > MAX_CONTROL_JSON_NODES) throw contractError(`${label} may contain at most ${MAX_CONTROL_JSON_NODES} JSON nodes`);
+        if (depth > MAX_CONTROL_JSON_DEPTH) throw contractError(`${label} may be at most ${MAX_CONTROL_JSON_DEPTH} levels deep`);
+        if (null === candidate || 'boolean' == typeof candidate || 'string' == typeof candidate) return void append(JSON.stringify(candidate));
+        if ('number' == typeof candidate) {
+            if (!Number.isFinite(candidate)) throw contractError(`${label} must contain only finite JSON numbers`);
+            append(JSON.stringify(candidate));
+            return;
+        }
+        if ('object' != typeof candidate) throw contractError(`${label} must contain only JSON-safe values`);
+        if ((0, __rspack_external_node_util_types_4d803828.isProxy)(candidate)) throw contractError(`${label} must not contain proxy objects`);
+        if (active.has(candidate)) throw contractError(`${label} must not contain cycles`);
+        active.add(candidate);
+        if (Array.isArray(candidate)) {
+            if (Object.getPrototypeOf(candidate) !== Array.prototype) throw contractError(`${label} must contain only plain JSON arrays`);
+            const descriptors = Object.getOwnPropertyDescriptors(candidate);
+            const ownKeys = Reflect.ownKeys(descriptors);
+            if (ownKeys.some((key)=>'string' != typeof key) || candidate.length + nodes > MAX_CONTROL_JSON_NODES || ownKeys.length !== candidate.length + 1) throw contractError(`${label} arrays must be dense and canonical`);
+            append('[');
+            for(let index = 0; index < candidate.length; index += 1){
+                const descriptor = descriptors[String(index)];
+                if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) throw contractError(`${label} arrays must be dense and canonical`);
+                if (index > 0) append(',');
+                visit(descriptor.value, depth + 1);
+            }
+            append(']');
+        } else {
+            const prototype = Object.getPrototypeOf(candidate);
+            if (prototype !== Object.prototype && null !== prototype) throw contractError(`${label} must contain only plain JSON objects`);
+            const descriptors = Object.getOwnPropertyDescriptors(candidate);
+            const ownKeys = Reflect.ownKeys(descriptors);
+            if (ownKeys.some((key)=>'string' != typeof key)) throw contractError(`${label} must contain only enumerable string-keyed properties`);
+            append('{');
+            for (const [index, key] of ownKeys.entries()){
+                const descriptor = descriptors[key];
+                if (!descriptor || !descriptor.enumerable || !('value' in descriptor)) throw contractError(`${label} must contain only enumerable data properties`);
+                if (index > 0) append(',');
+                append(JSON.stringify(key));
+                append(':');
+                visit(descriptor.value, depth + 1);
+            }
+            append('}');
+        }
+        active.delete(candidate);
+    };
+    visit(value, 0);
+}
+async function dispatchControlRequest(page, request) {
+    return page.evaluate(async ({ controlEvent, request })=>{
         const response = {};
         globalThis.dispatchEvent(new CustomEvent(controlEvent, {
             detail: {
-                event,
-                payload,
-                response,
-                runId
+                request,
+                response
             }
         }));
-        if (response.error) throw new Error(response.error);
-        if (!response.delivered) throw new Error(`The TAP frame host has no active subscriber for ${event}. Declare the event on the miniapp surface before using it in a test.`);
+        if (!response.promise || 'function' != typeof Reflect.get(response.promise, 'then')) throw new Error('The TAP frame host did not accept the Miniapp Test control request.');
+        return response.promise;
     }, {
         controlEvent: 'tap:miniapp-test-control',
+        request
+    });
+}
+function assertControlReceipt(receipt, session, requestId) {
+    if (1 !== receipt.schemaVersion) throw contractError('the host control receipt schemaVersion must be 1');
+    if (receipt.runId !== session.runId) throw contractError('the host control receipt belongs to another run');
+    if (receipt.requestId !== requestId) throw contractError('the host control receipt belongs to another request');
+}
+async function emitTapMiniappHostEvent(page, session, event, payload) {
+    if (event.length < 5 || event.length > 160 || !event.startsWith('tap.') || event.trim() !== event) throw contractError('host events must be bounded, trimmed tap.* event names');
+    if (void 0 !== payload) requireBoundedJson(payload, 'host event payload', MAX_HOST_EVENT_PAYLOAD_BYTES);
+    const request = miniappTestEmitHostEventControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: 'emit-host-event',
         event,
-        payload,
-        runId: session.runId
+        ...void 0 === payload ? {} : {
+            payload
+        }
+    });
+    const receipt = miniappTestEmitHostEventControlReceiptSchema.parse(await dispatchControlRequest(page, request));
+    assertControlReceipt(receipt, session, request.requestId);
+    requireUnsignedInteger(receipt.delivered, 'control.delivered', MAX_UINT32);
+    if (0 === receipt.delivered) throw contractError('control.delivered must be greater than zero');
+    return Object.freeze(receipt);
+}
+async function runTapMiniappLifecycleControl(page, session, operation) {
+    if ('reset-fixture' === operation && 'surface' !== session.mode) throw contractError('reset-fixture is available only in Surface mode');
+    const request = 'reset-fixture' === operation ? miniappTestResetFixtureControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation
+    }) : miniappTestRemountSurfaceControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation
+    });
+    const rawReceipt = await dispatchControlRequest(page, request);
+    const receipt = 'reset-fixture' === operation ? miniappTestResetFixtureControlReceiptSchema.parse(rawReceipt) : miniappTestRemountSurfaceControlReceiptSchema.parse(rawReceipt);
+    assertControlReceipt(receipt, session, request.requestId);
+    if (receipt.operation !== operation) throw contractError(`host control receipt operation ${receipt.operation} does not match ${operation}`);
+    const expectedMode = 'surface' === session.mode ? 'MINIAPP_TEST_MODE_SURFACE' : 'MINIAPP_TEST_MODE_LIVE_TAP';
+    if (receipt.mode !== expectedMode) throw contractError(`host control receipt mode ${receipt.mode} does not match ${session.mode}`);
+    if ('surface' === session.mode) {
+        if (void 0 === receipt.fixtureGeneration || void 0 === receipt.fixtureDigest) throw contractError('Surface lifecycle receipts require fixture generation and digest');
+        requireUnsignedInteger(receipt.fixtureGeneration, 'control.fixtureGeneration', MAX_UINT32);
+        if (0 === receipt.fixtureGeneration) throw contractError('control.fixtureGeneration must be greater than zero');
+        requireSha256(receipt.fixtureDigest, 'control.fixtureDigest');
+    } else if (void 0 !== receipt.fixtureGeneration || void 0 !== receipt.fixtureDigest) throw contractError('Live TAP lifecycle receipts must not contain fixture authority');
+    requireUnsignedInteger(receipt.surfaceGeneration, 'control.surfaceGeneration', MAX_UINT32);
+    if (0 === receipt.surfaceGeneration) throw contractError('control.surfaceGeneration must be greater than zero');
+    requireTrimmed(receipt.instanceId, 'control.instanceId');
+    requireTrimmed(receipt.documentId, 'control.documentId');
+    return Object.freeze({
+        ...receipt,
+        mode: session.mode,
+        fixtureGeneration: receipt.fixtureGeneration ?? null,
+        fixtureDigest: receipt.fixtureDigest ?? null
+    });
+}
+function requireSurfaceFixtureOperation(session, operation) {
+    if ('surface' !== session.mode) throw contractError(`${operation} is available only in Surface mode`);
+}
+function requireFixtureIdentity(value, label) {
+    requireUnsignedInteger(value.fixtureGeneration, `${label}.fixtureGeneration`, MAX_UINT32);
+    if (0 === value.fixtureGeneration) throw contractError(`${label}.fixtureGeneration must be greater than zero`);
+    requireSha256(value.fixtureDigest, `${label}.fixtureDigest`);
+}
+function generatedHttpHeaderInput(header) {
+    return {
+        name: header.name,
+        value: header.value,
+        ...void 0 === header.enabled || null === header.enabled ? {} : {
+            enabled: header.enabled
+        }
+    };
+}
+function generatedHttpRequest(request) {
+    return {
+        method: request.method,
+        url: request.url,
+        ...void 0 === request.query ? {} : {
+            query: request.query.map(generatedHttpHeaderInput)
+        },
+        ...void 0 === request.headers ? {} : {
+            headers: request.headers.map(generatedHttpHeaderInput)
+        },
+        ...void 0 === request.body || null === request.body ? {} : {
+            body: request.body
+        },
+        ...void 0 === request.timeoutMs || null === request.timeoutMs ? {} : {
+            timeoutMs: request.timeoutMs
+        },
+        ...void 0 === request.responseBodyLimitBytes || null === request.responseBodyLimitBytes ? {} : {
+            responseBodyLimitBytes: request.responseBodyLimitBytes
+        },
+        ...void 0 === request.followRedirects || null === request.followRedirects ? {} : {
+            followRedirects: request.followRedirects
+        }
+    };
+}
+function generatedHttpScript(script) {
+    if (void 0 !== script.credentialRef && void 0 !== script.auth) throw contractError("fixture HTTP scripts cannot combine credentialRef and auth");
+    requireTrimmed(script.request.method, 'fixture HTTP request method', 32);
+    requireHttpUrl(script.request.url, 'fixture HTTP request URL');
+    if ((script.request.query?.length ?? 0) > MAX_FIXTURE_COLLECTION_ITEMS || (script.request.headers?.length ?? 0) > MAX_FIXTURE_COLLECTION_ITEMS || script.response.headers.length > MAX_FIXTURE_COLLECTION_ITEMS) throw contractError(`fixture HTTP header collections may contain at most ${MAX_FIXTURE_COLLECTION_ITEMS} entries`);
+    if (void 0 !== script.repeat) {
+        requireUnsignedInteger(script.repeat, "fixture HTTP script repeat", MAX_FIXTURE_HTTP_REPEATS);
+        if (0 === script.repeat) throw contractError("fixture HTTP script repeat must be greater than zero");
+    }
+    requireHttpUrl(script.response.finalUrl, 'fixture HTTP response finalUrl');
+    requireUnsignedInteger(script.response.status, 'fixture HTTP response status', 599);
+    if (script.response.status < 100) throw contractError('fixture HTTP response status must be between 100 and 599');
+    if ('text' !== script.response.bodyKind && 'binary' !== script.response.bodyKind) throw contractError('fixture HTTP response bodyKind must be text or binary');
+    for (const nullableField of [
+        'bodyText',
+        'bodyBase64',
+        'contentType'
+    ])if (!Object.hasOwn(script.response, nullableField)) throw contractError(`fixture HTTP response ${nullableField} must be explicit, using null when absent`);
+    if (void 0 !== script.credentialRef) requireTrimmed(script.credentialRef, 'fixture HTTP credentialRef', 512);
+    const { bodyBase64, bodyKind, bodyText, contentType, ...response } = script.response;
+    return miniappTestFixtureHttpScriptSchema.parse({
+        request: generatedHttpRequest(script.request),
+        ...void 0 === script.credentialRef ? {} : {
+            credentialRef: script.credentialRef
+        },
+        ...void 0 === script.auth ? {} : {
+            auth: script.auth
+        },
+        response: {
+            ...response,
+            bodyKind,
+            ...null === bodyText ? {} : {
+                bodyText
+            },
+            ...null === bodyBase64 ? {} : {
+                bodyBase64
+            },
+            ...null === contentType ? {} : {
+                contentType
+            }
+        },
+        ...void 0 === script.repeat ? {} : {
+            repeat: script.repeat
+        }
+    });
+}
+function publicHttpScriptState(script) {
+    return {
+        ...script,
+        request: script.request,
+        response: {
+            ...script.response,
+            bodyText: script.response.bodyText ?? null,
+            bodyBase64: script.response.bodyBase64 ?? null,
+            contentType: script.response.contentType ?? null
+        }
+    };
+}
+function publicFixtureSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        state: {
+            ...snapshot.state,
+            httpScripts: snapshot.state.httpScripts.map(publicHttpScriptState)
+        }
+    };
+}
+function requireFixtureCollections(collections, label) {
+    for (const [name, entries] of Object.entries(collections))if (entries.length > MAX_FIXTURE_COLLECTION_ITEMS) throw contractError(`${label}.${name} may contain at most ${MAX_FIXTURE_COLLECTION_ITEMS} entries`);
+}
+function requireFixtureSnapshot(snapshot, session) {
+    requireFixtureIdentity(snapshot, 'control.snapshot');
+    if (snapshot.workspaceId !== session.workspaceId) throw contractError('fixture snapshot belongs to another workspace');
+    if (snapshot.channelId !== session.channelId) throw contractError('fixture snapshot belongs to another channel');
+    if (void 0 !== session.fixtureVersion && snapshot.fixtureVersion !== session.fixtureVersion) throw contractError('fixture snapshot version does not match the session');
+    requireUnsignedInteger(snapshot.clockTick, 'control.snapshot.clockTick', Number.MAX_SAFE_INTEGER);
+    requireFixtureCollections(snapshot.state, 'control.snapshot.state');
+}
+function requireFixtureHttpCaptures(captures) {
+    requireUnsignedInteger(captures.dropped, 'control.captures.dropped', MAX_UINT32);
+    if (captures.requests.length > MAX_FIXTURE_HTTP_CAPTURES) throw contractError(`control.captures.requests may contain at most ${MAX_FIXTURE_HTTP_CAPTURES} entries`);
+    let previousSequence = 0;
+    for (const capture of captures.requests){
+        requireUnsignedInteger(capture.sequence, 'control.captures.sequence', MAX_UINT32);
+        if (capture.sequence <= previousSequence) throw contractError('control.captures requests must have strictly increasing sequences');
+        previousSequence = capture.sequence;
+        requireTrimmed(capture.request.method, 'control.captures.request.method', 32);
+        requireHttpUrl(capture.request.url, 'control.captures.request.url');
+    }
+}
+function publicFixtureLedger(ledger) {
+    requireUnsignedInteger(ledger.dropped, 'control.ledger.dropped', MAX_UINT32);
+    if (ledger.entries.length > MAX_FIXTURE_LEDGER_ENTRIES) throw contractError(`control.ledger.entries may contain at most ${MAX_FIXTURE_LEDGER_ENTRIES} entries`);
+    let previousSequence = 0;
+    return {
+        ...ledger,
+        entries: ledger.entries.map((entry)=>{
+            requireUnsignedInteger(entry.sequence, 'control.ledger.sequence', MAX_UINT32);
+            if (entry.sequence <= previousSequence) throw contractError('control.ledger entries must have strictly increasing sequences');
+            previousSequence = entry.sequence;
+            requireUnsignedInteger(entry.fixtureGeneration, 'control.ledger.fixtureGeneration', MAX_UINT32);
+            if (0 === entry.fixtureGeneration) throw contractError('control.ledger.fixtureGeneration must be greater than zero');
+            requireUnsignedInteger(entry.timestampMs, 'control.ledger.timestampMs', Number.MAX_SAFE_INTEGER);
+            requireTrimmed(entry.operation, 'control.ledger.operation', 256);
+            return entry;
+        })
+    };
+}
+async function seedTapMiniappFixture(page, session, seed) {
+    requireSurfaceFixtureOperation(session, 'seed-fixture');
+    requireBoundedJson(seed, 'fixture seed', MAX_FIXTURE_SEED_BYTES);
+    const generatedSeed = miniappTestFixtureSeedSchema.parse({
+        ...seed,
+        httpScripts: (seed.httpScripts ?? []).map(generatedHttpScript)
+    });
+    requireFixtureCollections(generatedSeed, 'fixture seed');
+    const request = miniappTestSeedFixtureControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: 'seed-fixture',
+        seed: generatedSeed
+    });
+    const receipt = miniappTestSeedFixtureControlReceiptSchema.parse(await dispatchControlRequest(page, request));
+    assertControlReceipt(receipt, session, request.requestId);
+    requireFixtureIdentity(receipt, 'control.seed');
+    requireUnsignedInteger(receipt.surfaceGeneration, 'control.seed.surfaceGeneration', MAX_UINT32);
+    if (0 === receipt.surfaceGeneration) throw contractError('control.seed.surfaceGeneration must be greater than zero');
+    requireTrimmed(receipt.instanceId, 'control.seed.instanceId');
+    requireTrimmed(receipt.documentId, 'control.seed.documentId');
+    return Object.freeze(receipt);
+}
+async function snapshotTapMiniappFixture(page, session) {
+    requireSurfaceFixtureOperation(session, 'snapshot-fixture');
+    const request = miniappTestSnapshotFixtureControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: 'snapshot-fixture'
+    });
+    const rawReceipt = await dispatchControlRequest(page, request);
+    requireBoundedJson(rawReceipt, 'fixture snapshot receipt', MAX_CONTROL_RESULT_BYTES);
+    const receipt = miniappTestSnapshotFixtureControlReceiptSchema.parse(rawReceipt);
+    assertControlReceipt(receipt, session, request.requestId);
+    requireFixtureSnapshot(receipt.snapshot, session);
+    return Object.freeze(publicFixtureSnapshot(receipt.snapshot));
+}
+async function scriptTapMiniappHttp(page, session, script) {
+    requireSurfaceFixtureOperation(session, "script-http");
+    requireBoundedJson(script, "fixture HTTP script", MAX_FIXTURE_HTTP_SCRIPT_BYTES);
+    const request = miniappTestScriptHttpControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: "script-http",
+        script: generatedHttpScript(script)
     });
+    const receipt = miniappTestScriptHttpControlReceiptSchema.parse(await dispatchControlRequest(page, request));
+    assertControlReceipt(receipt, session, request.requestId);
+    requireUnsignedInteger(receipt.fixtureGeneration, "control.scriptHttp.fixtureGeneration", MAX_UINT32);
+    requireUnsignedInteger(receipt.scriptedRequests, "control.scriptHttp.scriptedRequests", MAX_UINT32);
+    if (0 === receipt.fixtureGeneration || 0 === receipt.scriptedRequests) throw contractError("script-http receipt counters must be greater than zero");
+    return Object.freeze(receipt);
+}
+async function readTapMiniappCapturedHttpRequests(page, session) {
+    requireSurfaceFixtureOperation(session, 'captured-http-requests');
+    const request = miniappTestCapturedHttpRequestsControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: 'captured-http-requests'
+    });
+    const rawReceipt = await dispatchControlRequest(page, request);
+    requireBoundedJson(rawReceipt, 'fixture HTTP capture receipt', MAX_CONTROL_RESULT_BYTES);
+    const receipt = miniappTestCapturedHttpRequestsControlReceiptSchema.parse(rawReceipt);
+    assertControlReceipt(receipt, session, request.requestId);
+    requireFixtureHttpCaptures(receipt.captures);
+    return Object.freeze(receipt.captures);
+}
+async function readTapMiniappFixtureLedger(page, session) {
+    requireSurfaceFixtureOperation(session, 'read-ledger');
+    const request = miniappTestReadLedgerControlRequestSchema.parse({
+        schemaVersion: 1,
+        requestId: `sdk-${(0, __rspack_external_node_crypto_2e7c4b46.randomUUID)()}`,
+        runId: session.runId,
+        operation: 'read-ledger'
+    });
+    const rawReceipt = await dispatchControlRequest(page, request);
+    requireBoundedJson(rawReceipt, 'fixture ledger receipt', MAX_CONTROL_RESULT_BYTES);
+    const receipt = miniappTestReadLedgerControlReceiptSchema.parse(rawReceipt);
+    assertControlReceipt(receipt, session, request.requestId);
+    return Object.freeze(publicFixtureLedger(receipt.ledger));
+}
+async function quiesceTapMiniappSurface(page, session) {
+    if ('surface' !== session.mode) return;
+    const expectedMarker = await page.locator(session.surfaceSelector).evaluate(async (element, identity)=>{
+        if (!(element instanceof HTMLIFrameElement)) throw new Error('The TAP Surface selector did not resolve to an iframe.');
+        const readyMarker = await new Promise((resolve, reject)=>{
+            const documentElement = globalThis.document.documentElement;
+            let observer;
+            const timeout = globalThis.setTimeout(()=>{
+                observer?.disconnect();
+                reject(new Error('The TAP Surface did not publish its exact active document before the isolation deadline.'));
+            }, 15000);
+            const acceptMarker = ()=>{
+                const marker = documentElement.dataset.tapMiniappTestSurfaceReady?.trim();
+                if (!marker) return false;
+                globalThis.clearTimeout(timeout);
+                observer?.disconnect();
+                resolve(marker);
+                return true;
+            };
+            if (acceptMarker()) return;
+            observer = new MutationObserver(()=>{
+                acceptMarker();
+            });
+            observer.observe(documentElement, {
+                attributes: true,
+                attributeFilter: [
+                    'data-tap-miniapp-test-surface-ready'
+                ]
+            });
+            acceptMarker();
+        });
+        const runtime = element.closest('[data-testid="miniapp-surface-test-runtime"]');
+        const runtimeRunId = runtime?.getAttribute('data-run-id');
+        const generationValue = runtime?.getAttribute('data-surface-generation');
+        const surfaceGeneration = Number(generationValue);
+        const sourceUrl = new URL(element.src);
+        const instanceId = sourceUrl.searchParams.get('instanceId');
+        const legacyInstanceIds = [
+            sourceUrl.searchParams.get('miniappInstanceId'),
+            sourceUrl.searchParams.get('miniappFrameId')
+        ].filter((candidate)=>null !== candidate);
+        let readyIdentity;
+        try {
+            const value = JSON.parse(readyMarker);
+            if ('object' == typeof value && null !== value) readyIdentity = value;
+        } catch  {}
+        if (runtimeRunId !== identity.runId || !Number.isSafeInteger(surfaceGeneration) || surfaceGeneration < 1 || sourceUrl.origin !== identity.surfaceAssetOrigin || !instanceId || legacyInstanceIds.some((candidate)=>candidate !== instanceId) || readyIdentity?.runId !== identity.runId || readyIdentity.surfaceGeneration !== surfaceGeneration || readyIdentity.instanceId !== instanceId || 'string' != typeof readyIdentity.documentId || 0 === readyIdentity.documentId.length || readyMarker !== JSON.stringify({
+            runId: identity.runId,
+            surfaceGeneration,
+            instanceId,
+            documentId: readyIdentity.documentId
+        })) throw new Error('The TAP Surface DOM identity does not match its exact run.');
+        const marker = readyMarker;
+        await new Promise((resolve, reject)=>{
+            const timeout = globalThis.setTimeout(()=>{
+                cleanup();
+                reject(new Error('The TAP Surface document did not quiesce before the isolation deadline.'));
+            }, 15000);
+            const cleanup = ()=>{
+                globalThis.clearTimeout(timeout);
+                element.removeEventListener('load', handleLoad);
+                element.removeEventListener('error', handleError);
+            };
+            const handleLoad = ()=>{
+                cleanup();
+                if ('about:blank' !== element.getAttribute('src')) return void reject(new Error('The TAP Surface document changed while it was being quiesced.'));
+                resolve();
+            };
+            const handleError = ()=>{
+                cleanup();
+                reject(new Error('The TAP Surface document could not be quiesced.'));
+            };
+            element.addEventListener('load', handleLoad, {
+                once: true
+            });
+            element.addEventListener('error', handleError, {
+                once: true
+            });
+            element.setAttribute('src', 'about:blank');
+        });
+        return marker;
+    }, {
+        runId: session.runId,
+        surfaceAssetOrigin: session.surfaceAssetOrigin
+    });
+    await page.waitForFunction((marker)=>document.documentElement.dataset.tapMiniappTestSurfaceQuiesced === marker, expectedMarker);
+    return expectedMarker;
+}
+async function clearTapMiniappSurfaceBrowserState(context, page, session) {
+    if ('surface' !== session.mode) return;
+    let cdp;
+    try {
+        cdp = await context.newCDPSession(page);
+        await cdp.send('Storage.clearDataForOrigin', {
+            origin: session.surfaceAssetOrigin,
+            storageTypes: 'all'
+        });
+        await cdp.send('DOMStorage.clear', {
+            storageId: {
+                isLocalStorage: true,
+                securityOrigin: session.surfaceAssetOrigin
+            }
+        });
+        await cdp.send('DOMStorage.clear', {
+            storageId: {
+                isLocalStorage: false,
+                securityOrigin: session.surfaceAssetOrigin
+            }
+        });
+        await cdp.send('Network.clearBrowserCache');
+    } finally{
+        await cdp?.detach();
+    }
+}
+async function inspectPageTarget(context, page) {
+    let cdp;
+    try {
+        cdp = await context.newCDPSession(page);
+        const response = cdpTargetInfoResponseSchema.parse(await cdp.send('Target.getTargetInfo'));
+        return {
+            browserContextId: response.targetInfo.browserContextId,
+            context,
+            page,
+            targetId: response.targetInfo.targetId,
+            type: response.targetInfo.type,
+            url: response.targetInfo.url
+        };
+    } finally{
+        await cdp?.detach();
+    }
+}
+function assertExactTarget(targets, session) {
+    const matchingIdentity = targets.filter((target)=>target.targetId === session.targetId);
+    if (1 !== matchingIdentity.length) throw new Error(`TAP Browser Driver exposed ${matchingIdentity.length} pages with target ${session.targetId} for run ${session.runId}; expected exactly one.`);
+    const target = matchingIdentity[0];
+    if (!target) throw new Error('TAP Browser Driver target selection failed');
+    if (target.type !== session.targetType || target.url !== session.pageUrl || target.page.url() !== session.pageUrl) throw new Error(`TAP Browser Driver target ${session.targetId} did not match its declared page identity.`);
+    if (void 0 !== session.browserContextId && target.browserContextId !== session.browserContextId) throw new Error(`TAP Browser Driver target ${session.targetId} did not match its declared browser context.`);
+    return target;
+}
+async function resolveExactTapMiniappTarget(browser, session) {
+    const targets = await Promise.all(browser.contexts().flatMap((context)=>context.pages().map((page)=>inspectPageTarget(context, page))));
+    const target = assertExactTarget(targets, session);
+    return Object.freeze({
+        context: target.context,
+        page: target.page
+    });
+}
+async function resolveExactTapMiniappPage(context, session) {
+    const targets = await Promise.all(context.pages().map((page)=>inspectPageTarget(context, page)));
+    return assertExactTarget(targets, session).page;
+}
+const SESSION_ENV = 'TAP_MINIAPP_TEST_SESSION_FILE';
+let sessionPromise;
+let sessionDocumentPromise;
+let browserPromise;
+function parseTapMiniappTestSession(value) {
+    return parseValidatedTapMiniappTestSession(value);
+}
+async function loadSessionDocument() {
+    sessionDocumentPromise ??= (async ()=>{
+        const sessionPath = process.env[SESSION_ENV]?.trim();
+        if (!sessionPath) throw new Error(`${SESSION_ENV} is missing. Start this suite from The AI Platform Miniapp Test Lab.`);
+        const raw = await (0, __rspack_external_node_fs_promises_3b710708.readFile)(sessionPath, 'utf8');
+        return JSON.parse(raw);
+    })();
+    return sessionDocumentPromise;
+}
+async function loadSession() {
+    sessionPromise ??= loadSessionDocument().then((value)=>parseTapMiniappTestSession(value));
+    return sessionPromise;
 }
 function fixtureMetadata(session, page) {
+    const reset = ()=>runTapMiniappLifecycleControl(page, session, 'reset-fixture');
+    const remountSurface = ()=>runTapMiniappLifecycleControl(page, session, 'remount-surface');
+    const emitHostEvent = (event, payload)=>emitTapMiniappHostEvent(page, session, event, payload);
     return Object.freeze({
         allowedNetworkOrigins: Object.freeze([
             ...session.allowedNetworkOrigins
         ]),
+        adapterVersion: session.adapterVersion,
         channelId: session.channelId,
         credentialAliases: Object.freeze([
             ...session.credentialAliases
         ]),
         control: Object.freeze({
-            emitHostEvent: (event, payload)=>emitHostEvent(page, session, event, payload),
-            reset: async ()=>{
-                await page.reload({
-                    waitUntil: 'domcontentloaded'
-                });
-                await page.locator(session.surfaceSelector).waitFor({
-                    state: 'attached'
-                });
-            }
+            emitHostEvent,
+            remountSurface,
+            reset
         }),
         dataScope: session.dataScope,
+        descriptorDigest: session.descriptorDigest,
+        environment: session.environment,
+        artifacts: session.artifacts,
         installationId: session.installationId,
+        fixtureDigest: session.fixtureDigest,
+        hostContractVersion: session.hostContractVersion,
+        hostVersion: session.hostVersion,
+        fixture: Object.freeze({
+            schemaVersion: 1,
+            reset,
+            seed: (seed)=>seedTapMiniappFixture(page, session, seed),
+            snapshot: ()=>snapshotTapMiniappFixture(page, session),
+            http: Object.freeze({
+                script: (script)=>scriptTapMiniappHttp(page, session, script),
+                requests: ()=>readTapMiniappCapturedHttpRequests(page, session)
+            }),
+            ledger: Object.freeze({
+                read: ()=>readTapMiniappFixtureLedger(page, session)
+            })
+        }),
         localGeneration: session.localGeneration,
         mode: session.mode,
+        matrixEntryId: session.matrixEntryId,
         packageId: session.packageId,
         permissionScenario: session.permissionScenario,
+        policyDigest: session.policyDigest,
+        profileId: session.profileId,
         releaseDigest: session.releaseDigest,
         runId: session.runId,
+        runnerName: session.runnerName,
+        runnerVersion: session.runnerVersion,
+        seed: session.seed,
         sourceDigest: session.sourceDigest,
         surfaceAssetOrigin: session.surfaceAssetOrigin,
         surfaceId: session.surfaceId,
         testBundleDigest: session.testBundleDigest,
+        target: session.target,
         workspaceId: session.workspaceId
     });
 }
 function safeArtifactSegment(value) {
-    return value.replaceAll(/[^a-zA-Z0-9._-]/g, '-').slice(0, 160);
+    const slug = value.replaceAll(/[^a-zA-Z0-9._-]/g, '-');
+    const digest = (0, __rspack_external_node_crypto_2e7c4b46.createHash)('sha256').update(value).digest('hex').slice(0, 16);
+    return `${slug.slice(0, 143)}-${digest}`;
 }
-const HTTP_PROTOCOLS = new Set([
+const rstest_HTTP_PROTOCOLS = new Set([
     'http:',
     'https:'
 ]);
@@ -125,12 +1535,12 @@ const SAFE_INTERNAL_PROTOCOLS = new Set([
 ]);
 function explicitHttpOrigin(value, label) {
     const url = new URL(value);
-    if (!HTTP_PROTOCOLS.has(url.protocol)) throw new Error(`${label} must use HTTP or HTTPS.`);
+    if (!rstest_HTTP_PROTOCOLS.has(url.protocol)) throw new Error(`${label} must use HTTP or HTTPS.`);
     return url.origin;
 }
 function allowedHttpOrigins(session) {
     return new Set([
-        explicitHttpOrigin(session.pageUrlPrefix, 'TAP host page URL prefix'),
+        explicitHttpOrigin(session.pageUrl, 'TAP host page URL'),
         explicitHttpOrigin(session.surfaceAssetOrigin, 'Surface asset origin'),
         ...session.allowedNetworkOrigins.map((value)=>explicitHttpOrigin(value, 'Allowed network origin'))
     ]);
@@ -154,7 +1564,7 @@ function classifyRequestUrl(value, allowedOrigins) {
         reason: 'file-scheme',
         target: 'file:'
     };
-    if (!HTTP_PROTOCOLS.has(url.protocol)) return {
+    if (!rstest_HTTP_PROTOCOLS.has(url.protocol)) return {
         action: 'abort',
         reason: 'unsupported-scheme',
         target: url.protocol.slice(0, 32)
@@ -205,24 +1615,55 @@ function reportUnexpectedWebSocket(webSocket, allowedOrigins) {
         type: 'Warning'
     });
 }
+async function applyTapMiniappTestEnvironment(context, page, session) {
+    const { environment } = session;
+    if (void 0 !== environment.fixedNow) await page.clock.setFixedTime(environment.fixedNow);
+    await page.setViewportSize(environment.viewport);
+    await page.emulateMedia({
+        colorScheme: environment.theme,
+        reducedMotion: environment.reducedMotion ? 'reduce' : 'no-preference'
+    });
+    const cdp = await context.newCDPSession(page);
+    try {
+        await cdp.send('Emulation.setLocaleOverride', {
+            locale: environment.locale
+        });
+        await cdp.send('Emulation.setTimezoneOverride', {
+            timezoneId: environment.timezone
+        });
+    } finally{
+        await cdp.detach();
+    }
+}
+function shouldSaveArtifact(policy, failed) {
+    return 'always' === policy || 'failure-only' === policy && failed;
+}
+async function enforceArtifactBudget(paths, maximumBytes) {
+    if (void 0 === maximumBytes) return;
+    const sizes = await Promise.all(paths.map((artifactPath)=>(0, __rspack_external_node_fs_promises_3b710708.stat)(artifactPath)));
+    const total = sizes.reduce((sum, entry)=>sum + entry.size, 0);
+    if (total <= maximumBytes) return;
+    await Promise.all(paths.map((artifactPath)=>(0, __rspack_external_node_fs_promises_3b710708.rm)(artifactPath, {
+            force: true
+        })));
+    throw new Error(`TAP test artifacts used ${total} bytes, exceeding the profile limit of ${maximumBytes} bytes.`);
+}
 const test = __rspack_external__rstest_playwright_5734ff29.test.extend({
     browser: async (_context, use)=>{
-        const session = await loadSession();
-        browserPromise ??= __rspack_external_playwright.chromium.connectOverCDP(session.cdpEndpoint, {
-            headers: {
-                authorization: `Bearer ${session.cdpAuthorization}`,
-                'x-tap-miniapp-test-run': session.runId
-            }
-        });
+        browserPromise ??= (async ()=>{
+            const connected = await connectValidatedTapMiniappTestSession(await loadSessionDocument(), (endpoint, options)=>__rspack_external_playwright.chromium.connectOverCDP(endpoint, {
+                    headers: {
+                        ...options.headers
+                    }
+                }));
+            sessionPromise ??= Promise.resolve(connected.session);
+            return connected.connection;
+        })();
         await use(await browserPromise);
     },
-    context: async ({ browser, task }, use)=>{
+    context: async ({ browser, onTestFailed, onTestFinished, task }, use)=>{
         const session = await loadSession();
-        const contexts = browser.contexts().filter((candidate)=>candidate.pages().some((page)=>page.url().startsWith(session.pageUrlPrefix)));
-        if (1 !== contexts.length) throw new Error(`TAP Browser Driver exposed ${contexts.length} matching contexts for run ${session.runId}; expected exactly one.`);
-        const context = contexts[0];
-        if (!context) throw new Error('TAP Browser Driver context selection failed');
-        const hostPage = selectPage(context, session);
+        const { context, page: hostPage } = await resolveExactTapMiniappTarget(browser, session);
         const allowedOrigins = allowedHttpOrigins(session);
         const enforceDiagnosticNetworkPolicy = async (route)=>{
             const decision = classifyRequestUrl(route.request().url(), allowedOrigins);
@@ -232,79 +1673,121 @@ const test = __rspack_external__rstest_playwright_5734ff29.test.extend({
         const diagnoseWebSocket = (webSocket)=>reportUnexpectedWebSocket(webSocket, allowedOrigins);
         await context.route('**/*', enforceDiagnosticNetworkPolicy);
         hostPage.on('websocket', diagnoseWebSocket);
-        try {
-            const traceDirectory = (0, __rspack_external_node_path_806ed179.join)(session.artifactDirectory, 'traces', safeArtifactSegment(task.id));
-            await (0, __rspack_external_node_fs_promises_3b710708.mkdir)(traceDirectory, {
-                recursive: true
-            });
-            await context.tracing.start({
-                screenshots: true,
-                snapshots: true,
-                sources: true
-            });
+        const artifactDirectory = (0, __rspack_external_node_path_806ed179.join)(session.artifactDirectory, 'cases', safeArtifactSegment(task.id));
+        const traceEnabled = 'off' !== session.artifacts.trace;
+        let finalized = false;
+        if (traceEnabled) await context.tracing.start({
+            screenshots: true,
+            snapshots: true,
+            sources: true,
+            title: task.name
+        });
+        const finalize = async (failed)=>{
+            if (finalized) return;
+            finalized = true;
+            const savedPaths = [];
+            const tracePath = (0, __rspack_external_node_path_806ed179.join)(artifactDirectory, 'trace.zip');
+            const screenshotPath = (0, __rspack_external_node_path_806ed179.join)(artifactDirectory, 'screenshot.png');
+            const summaryPath = (0, __rspack_external_node_path_806ed179.join)(artifactDirectory, 'artifact-summary.json');
+            const debugPath = (0, __rspack_external_node_path_806ed179.join)(artifactDirectory, 'debug.md');
             try {
-                await use(context);
+                if (shouldSaveArtifact(session.artifacts.screenshots, failed)) {
+                    await (0, __rspack_external_node_fs_promises_3b710708.mkdir)(artifactDirectory, {
+                        recursive: true
+                    });
+                    await hostPage.screenshot({
+                        path: screenshotPath,
+                        fullPage: true
+                    });
+                    savedPaths.push(screenshotPath);
+                }
+                if (traceEnabled && shouldSaveArtifact(session.artifacts.trace, failed)) {
+                    await (0, __rspack_external_node_fs_promises_3b710708.mkdir)(artifactDirectory, {
+                        recursive: true
+                    });
+                    await context.tracing.stop({
+                        path: tracePath
+                    });
+                    savedPaths.push(tracePath);
+                } else if (traceEnabled) await context.tracing.stop();
+                if (savedPaths.length > 0) {
+                    const traceSummary = {
+                        schemaVersion: 3,
+                        runId: session.runId,
+                        taskId: task.id,
+                        failed,
+                        mode: session.mode,
+                        dataScope: session.dataScope,
+                        packageId: session.packageId,
+                        surfaceId: session.surfaceId,
+                        environment: session.environment,
+                        artifactPolicy: session.artifacts,
+                        sourceDigest: session.sourceDigest,
+                        testBundleDigest: session.testBundleDigest,
+                        networkPolicyRole: 'diagnostic-only',
+                        tracePath: savedPaths.includes(tracePath) ? 'trace.zip' : null,
+                        screenshotPath: savedPaths.includes(screenshotPath) ? 'screenshot.png' : null,
+                        traceRedacted: false,
+                        traceSensitivity: 'raw-sensitive',
+                        traceAccessScope: 'channel-only',
+                        traceMayContain: [
+                            'authorization headers',
+                            'cookies',
+                            'credential values',
+                            'network request and response bodies',
+                            'DOM snapshots',
+                            'screenshots',
+                            'test sources'
+                        ]
+                    };
+                    await Promise.all([
+                        (0, __rspack_external_node_fs_promises_3b710708.writeFile)(summaryPath, `${JSON.stringify(traceSummary, void 0, 2)}\n`, 'utf8'),
+                        (0, __rspack_external_node_fs_promises_3b710708.writeFile)(debugPath, [
+                            '# Miniapp test artifacts',
+                            '',
+                            `- Run: \`${session.runId}\``,
+                            `- Rstest task: \`${task.id}\``,
+                            `- Mode: \`${session.mode}\``,
+                            `- Data scope: \`${session.dataScope}\``,
+                            `- Surface: \`${session.surfaceId}\``,
+                            `- Source digest: \`${session.sourceDigest}\``,
+                            `- Test bundle digest: \`${session.testBundleDigest}\``,
+                            '- Browser network routing: diagnostic-only; not native egress enforcement',
+                            '',
+                            'These files are raw, sensitive, channel-only evidence. They are not redacted and may contain authorization headers, cookies, credential values, network bodies, DOM snapshots, screenshots, and test source.',
+                            '',
+                            'Open artifacts from The AI Platform Test Lab for debugging. Do not publish them or attach them to specialist context. The final assertion outcome is authoritative in `report.json` and `report.md`.',
+                            ''
+                        ].join('\n'), 'utf8')
+                    ]);
+                    savedPaths.push(summaryPath, debugPath);
+                }
+                await enforceArtifactBudget(savedPaths, session.artifacts.maxBytes);
             } finally{
-                await context.tracing.stop({
-                    path: (0, __rspack_external_node_path_806ed179.join)(traceDirectory, 'trace.zip')
-                });
-                const traceSummary = {
-                    schemaVersion: 2,
-                    runId: session.runId,
-                    taskId: task.id,
-                    mode: session.mode,
-                    dataScope: session.dataScope,
-                    packageId: session.packageId,
-                    surfaceId: session.surfaceId,
-                    sourceDigest: session.sourceDigest,
-                    testBundleDigest: session.testBundleDigest,
-                    networkPolicyRole: 'diagnostic-only',
-                    tracePath: 'trace.zip',
-                    traceRedacted: false,
-                    traceSensitivity: 'raw-sensitive',
-                    traceAccessScope: 'channel-only',
-                    traceMayContain: [
-                        'authorization headers',
-                        'cookies',
-                        'credential values',
-                        'network request and response bodies',
-                        'DOM snapshots',
-                        'screenshots',
-                        'test sources'
-                    ]
-                };
-                await Promise.all([
-                    (0, __rspack_external_node_fs_promises_3b710708.writeFile)((0, __rspack_external_node_path_806ed179.join)(traceDirectory, 'trace-summary.json'), `${JSON.stringify(traceSummary, void 0, 2)}\n`, 'utf8'),
-                    (0, __rspack_external_node_fs_promises_3b710708.writeFile)((0, __rspack_external_node_path_806ed179.join)(traceDirectory, 'debug.md'), [
-                        '# Miniapp test trace',
-                        '',
-                        `- Run: \`${session.runId}\``,
-                        `- Rstest task: \`${task.id}\``,
-                        `- Mode: \`${session.mode}\``,
-                        `- Data scope: \`${session.dataScope}\``,
-                        `- Surface: \`${session.surfaceId}\``,
-                        `- Source digest: \`${session.sourceDigest}\``,
-                        `- Test bundle digest: \`${session.testBundleDigest}\``,
-                        '- Browser network routing: diagnostic-only; not native egress enforcement',
-                        '',
-                        '`trace.zip` is raw, sensitive, channel-only evidence. It is not redacted and may contain authorization headers, cookies, credential values, network bodies, DOM snapshots, screenshots, and test source.',
-                        '',
-                        'Open the trace from The AI Platform Test Lab for debugging. Do not publish it or attach it to specialist context. The final assertion outcome is authoritative in `report.json` and `report.md`.',
-                        ''
-                    ].join('\n'), 'utf8')
-                ]);
+                hostPage.removeListener('websocket', diagnoseWebSocket);
+                await context.unroute('**/*', enforceDiagnosticNetworkPolicy);
             }
-        } finally{
-            hostPage.removeListener('websocket', diagnoseWebSocket);
-            await context.unroute('**/*', enforceDiagnosticNetworkPolicy);
+        };
+        onTestFailed(()=>finalize(true), 0);
+        try {
+            await use(context);
+        } catch (error) {
+            await finalize(true);
+            throw error;
         }
+        if (task.result?.status === 'fail') await finalize(true);
+        else onTestFinished(()=>finalize(task.result?.status === 'fail'), 0);
     },
     page: async ({ context }, use)=>{
         const session = await loadSession();
-        const page = selectPage(context, session);
+        const page = await resolveExactTapMiniappPage(context, session);
+        await applyTapMiniappTestEnvironment(context, page, session);
         await page.locator(session.surfaceSelector).waitFor({
             state: 'attached'
         });
+        await page.waitForFunction((runId)=>document.documentElement.dataset.tapMiniappTestControlRun === runId, session.runId);
+        await quiesceTapMiniappSurface(page, session);
+        await clearTapMiniappSurfaceBrowserState(context, page, session);
         await use(page);
     },
     surface: async ({ page }, use)=>{
@@ -313,7 +1796,16 @@ const test = __rspack_external__rstest_playwright_5734ff29.test.extend({
     },
     tap: async ({ page }, use)=>{
         await use(fixtureMetadata(await loadSession(), page));
-    }
+    },
+    __tapMiniappHookContext: [
+        async ({ browser, context, page, surface, tap }, use)=>{
+            if ('surface' === tap.mode) await tap.fixture.reset();
+            await use(void 0);
+        },
+        {
+            auto: true
+        }
+    ]
 });
 const afterEach = __rspack_external__rstest_playwright_5734ff29.afterEach;
 const beforeEach = __rspack_external__rstest_playwright_5734ff29.beforeEach;