@react-native-harness/platform-android 1.2.0 → 1.4.0-rc.1

package/dist/crash-diagnostics.js

@@ -0,0 +1,256 @@
+import { escapeRegExp, logger } from '@react-native-harness/tools';
+import { androidCrashParser } from './crash-parser.js';
+const crashDiagnosticsLogger = logger.child('android-crash-diagnostics');
+const DROPBOX_ENTRY_HEADER = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}(?:\.\d{3})?) (\S+) \(text, \d+ bytes\)/;
+const DROPBOX_POLL_INTERVAL_MS = 1500;
+const DROPBOX_WAIT_TIMEOUT_MS = 10000;
+export const DROPBOX_CRASH_TAGS = [
+    'data_app_crash',
+    'data_app_native_crash',
+];
+const getDropboxArtifactType = (tag) => tag === 'data_app_native_crash' ? 'dropbox-native-crash' : 'dropbox-crash';
+const getDropboxFileName = (tag) => tag === 'data_app_native_crash'
+    ? 'dropbox-native-crash.txt'
+    : 'dropbox-crash.txt';
+const parseDropboxTimestamp = (timestamp) => {
+    const match = timestamp.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(?:\.(\d{3}))?$/);
+    if (!match) {
+        return 0;
+    }
+    const [, year, month, day, hour, minute, second, millis = '0'] = match;
+    return Date.UTC(Number(year), Number(month) - 1, Number(day), Number(hour), Number(minute), Number(second), Number(millis));
+};
+const extractDropboxPid = (content) => {
+    const match = content.match(/^PID:\s*(\d+)/m) ?? content.match(/\bpid:\s*(\d+)/im);
+    return match ? Number(match[1]) : undefined;
+};
+const extractDropboxProcessName = (content, bundleId) => {
+    const processMatch = content.match(/^Process:\s*(\S+)/m);
+    const packageMatch = content.match(/^Package:\s*(\S+)/m);
+    if (processMatch?.[1] === bundleId) {
+        return processMatch[1];
+    }
+    if (packageMatch?.[1]?.startsWith(bundleId)) {
+        return bundleId;
+    }
+    return content.includes(bundleId) ? bundleId : undefined;
+};
+export const parseDropboxOutput = (output) => {
+    if (output.trim() === '') {
+        return [];
+    }
+    const sections = output.split(/^={10,}\s*$/m);
+    const entries = [];
+    for (const section of sections) {
+        const trimmedSection = section.trim();
+        if (trimmedSection === '') {
+            continue;
+        }
+        const lines = trimmedSection.split('\n');
+        const headerIndex = lines.findIndex((line) => DROPBOX_ENTRY_HEADER.test(line.trim()));
+        if (headerIndex === -1) {
+            continue;
+        }
+        const headerMatch = lines[headerIndex].trim().match(DROPBOX_ENTRY_HEADER);
+        if (!headerMatch) {
+            continue;
+        }
+        const [, timestamp, tag] = headerMatch;
+        const content = lines.slice(headerIndex + 1).join('\n').trim();
+        if (content === '') {
+            continue;
+        }
+        entries.push({
+            tag,
+            timestamp,
+            content,
+            pid: extractDropboxPid(content),
+        });
+    }
+    return entries;
+};
+const matchesDropboxEntry = ({ entry, bundleId, pid, }) => {
+    const processName = extractDropboxProcessName(entry.content, bundleId);
+    if (!processName) {
+        return false;
+    }
+    if (pid !== undefined && entry.pid !== undefined && entry.pid !== pid) {
+        return false;
+    }
+    return true;
+};
+const scoreDropboxEntry = ({ entry, bundleId, pid, occurredAt, }) => {
+    let score = 0;
+    if (extractDropboxProcessName(entry.content, bundleId) === bundleId) {
+        score += 100;
+    }
+    if (pid !== undefined && entry.pid === pid) {
+        score += 200;
+    }
+    const entryTimestamp = parseDropboxTimestamp(entry.timestamp);
+    if (entryTimestamp > 0) {
+        score -= Math.min(Math.abs(entryTimestamp - occurredAt) / 1000, 300);
+    }
+    if (entry.tag === 'data_app_native_crash') {
+        score += 25;
+    }
+    return score;
+};
+const toDropboxCrashArtifact = ({ entry, bundleId, pid, occurredAt, lookup, }) => {
+    const parsed = androidCrashParser.parse({
+        contents: entry.content,
+        bundleId,
+        pid: pid ?? entry.pid,
+    });
+    const artifactType = getDropboxArtifactType(entry.tag);
+    return {
+        ...parsed,
+        source: 'logs',
+        summary: entry.content,
+        rawLines: entry.content.split(/\r?\n/),
+        artifactType,
+        dropboxTag: entry.tag,
+        occurredAt,
+        score: scoreDropboxEntry({
+            entry,
+            bundleId,
+            pid: lookup?.pid ?? pid,
+            occurredAt: lookup?.occurredAt ?? occurredAt,
+        }),
+    };
+};
+const getMatchingDropboxEntries = ({ output, bundleId, pid, occurredAt, minOccurredAt, }) => parseDropboxOutput(output)
+    .filter((entry) => matchesDropboxEntry({ entry, bundleId, pid }))
+    .filter((entry) => {
+    const entryOccurredAt = parseDropboxTimestamp(entry.timestamp);
+    return (minOccurredAt === undefined ||
+        entryOccurredAt === 0 ||
+        entryOccurredAt >= minOccurredAt);
+})
+    .map((entry) => toDropboxCrashArtifact({
+    entry,
+    bundleId,
+    pid,
+    occurredAt: parseDropboxTimestamp(entry.timestamp) || occurredAt,
+}))
+    .sort((left, right) => {
+    if ((right.score ?? 0) !== (left.score ?? 0)) {
+        return (right.score ?? 0) - (left.score ?? 0);
+    }
+    return right.occurredAt - left.occurredAt;
+});
+const persistDropboxArtifact = ({ artifact, crashArtifactWriter, testFilePath, }) => {
+    if (!crashArtifactWriter) {
+        return artifact;
+    }
+    return {
+        ...artifact,
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: artifact.artifactType,
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: getDropboxFileName(artifact.dropboxTag),
+                text: `${artifact.summary ?? ''}\n`,
+            },
+        }),
+    };
+};
+export const collectDropboxArtifacts = async ({ bundleId, crashArtifactWriter, getDropboxOutput, minOccurredAt, ...lookup }) => {
+    crashDiagnosticsLogger.debug('collecting dropbox crash artifacts: %o', {
+        bundleId,
+        pid: lookup.pid,
+        occurredAt: lookup.occurredAt,
+    });
+    let output = '';
+    try {
+        output = await getDropboxOutput();
+    }
+    catch (error) {
+        crashDiagnosticsLogger.debug('failed to read dropbox entries', error);
+        return [];
+    }
+    return getMatchingDropboxEntries({
+        output,
+        bundleId,
+        pid: lookup.pid,
+        occurredAt: lookup.occurredAt,
+        minOccurredAt,
+    }).map((artifact) => persistDropboxArtifact({
+        artifact,
+        crashArtifactWriter,
+        testFilePath: lookup.testFilePath,
+    }));
+};
+export const waitForDropboxArtifacts = async (options) => {
+    const deadline = Date.now() + DROPBOX_WAIT_TIMEOUT_MS;
+    let latestArtifacts = [];
+    while (Date.now() < deadline) {
+        latestArtifacts = await collectDropboxArtifacts(options);
+        if (latestArtifacts.length > 0) {
+            return latestArtifacts;
+        }
+        if (Date.now() >= deadline) {
+            return latestArtifacts;
+        }
+        await new Promise((resolve) => setTimeout(resolve, DROPBOX_POLL_INTERVAL_MS));
+    }
+    return latestArtifacts;
+};
+export const filterExitInfo = ({ output, bundleId, pid, }) => {
+    if (output.trim() === '' || /No exit info records/i.test(output)) {
+        return null;
+    }
+    const packagePattern = new RegExp(`\\bpackage=${escapeRegExp(bundleId)}\\b`, 'i');
+    if (!packagePattern.test(output)) {
+        return null;
+    }
+    const sections = output.split(/(?=ApplicationExitInfo\b)/);
+    const matchingSections = sections.filter((section) => {
+        if (!packagePattern.test(section)) {
+            return false;
+        }
+        if (pid === undefined) {
+            return true;
+        }
+        return new RegExp(`\\bpid=${pid}\\b`).test(section);
+    });
+    if (matchingSections.length === 0) {
+        return packagePattern.test(output) ? output.trim() : null;
+    }
+    return matchingSections.join('\n').trim();
+};
+export const collectExitInfoArtifact = async ({ bundleId, crashArtifactWriter, getExitInfo, pid, testFilePath, }) => {
+    let output = '';
+    try {
+        output = await getExitInfo();
+    }
+    catch (error) {
+        crashDiagnosticsLogger.debug('failed to read activity exit-info', error);
+        return null;
+    }
+    const filtered = filterExitInfo({ output, bundleId, pid });
+    if (!filtered) {
+        return null;
+    }
+    if (!crashArtifactWriter) {
+        return {
+            artifactType: 'exit-info',
+            artifactPath: filtered,
+        };
+    }
+    return {
+        artifactType: 'exit-info',
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: 'exit-info',
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: 'exit-info.txt',
+                text: `${filtered}\n`,
+            },
+        }),
+    };
+};
+export const getBestDropboxArtifact = (artifacts) => [...artifacts].sort((left, right) => (right.score ?? 0) - (left.score ?? 0))[0] ??
+    null;

package/dist/crash-reporter.d.ts

@@ -0,0 +1,12 @@
+import type { AppCrashDetails, AppSessionLog, CrashArtifactWriter, CrashDetailsLookupOptions } from '@react-native-harness/platforms';
+export declare const createAndroidCrashReporter: ({ bundleId, crashArtifactWriter, getLogs, getDropboxOutput, getExitInfo, minOccurredAt, }: {
+    bundleId: string;
+    crashArtifactWriter?: CrashArtifactWriter;
+    getLogs: () => AppSessionLog[];
+    getDropboxOutput?: () => Promise<string>;
+    getExitInfo?: () => Promise<string>;
+    minOccurredAt?: number;
+}) => {
+    getCrashDetails: ({ occurredAt, pid, testFilePath, }: CrashDetailsLookupOptions) => Promise<AppCrashDetails | null>;
+};
+//# sourceMappingURL=crash-reporter.d.ts.map

package/dist/crash-reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crash-reporter.d.ts","sourceRoot":"","sources":["../src/crash-reporter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,aAAa,EACb,mBAAmB,EACnB,yBAAyB,EAE1B,MAAM,iCAAiC,CAAC;AAsKzC,eAAO,MAAM,0BAA0B,GAAI,2FAOxC;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,OAAO,EAAE,MAAM,aAAa,EAAE,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACzC,WAAW,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;0DAKI,yBAAyB,KAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC;CAuE9D,CAAC"}

package/dist/crash-reporter.js

@@ -0,0 +1,150 @@
+import { androidCrashParser } from './crash-parser.js';
+import { collectExitInfoArtifact, waitForDropboxArtifacts, getBestDropboxArtifact, } from './crash-diagnostics.js';
+const CRASH_ARTIFACT_SETTLE_DELAY_MS = 100;
+const CRASH_BLOCK_HEADER = '--------- beginning of crash';
+const CRASH_LOG_WINDOW_MS = 5000;
+const findCrashBlockStart = (lines) => {
+    let latestCrashHeaderIndex = -1;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        if (/FATAL EXCEPTION:|Process:\s+.+,\s+PID:|>>>\s+.+\s+<<</i.test(lines[index])) {
+            latestCrashHeaderIndex = index;
+            break;
+        }
+    }
+    const latestBlockHeaderIndex = lines.lastIndexOf(CRASH_BLOCK_HEADER);
+    return latestBlockHeaderIndex >= 0
+        ? latestBlockHeaderIndex
+        : latestCrashHeaderIndex;
+};
+const getCrashBlock = (logs, occurredAt) => {
+    const nearbyLogs = logs.filter((log) => Math.abs(log.occurredAt - occurredAt) <= CRASH_LOG_WINDOW_MS);
+    const lines = nearbyLogs.length > 0
+        ? nearbyLogs.map((log) => log.line)
+        : logs.map((log) => log.line);
+    const blockStart = findCrashBlockStart(lines);
+    return blockStart >= 0 ? lines.slice(blockStart) : lines;
+};
+const hasUsefulLogcatBlock = (rawLines) => rawLines.some((line) => /FATAL EXCEPTION:|Process:\s+.+,\s+PID:|>>>\s+.+\s+<<</i.test(line));
+const getLogcatCrashDetails = ({ rawLines, bundleId, pid, }) => ({
+    ...androidCrashParser.parse({
+        contents: rawLines.join('\n'),
+        bundleId,
+        pid,
+    }),
+    artifactType: 'logcat',
+    rawLines,
+});
+const persistLogcatArtifact = ({ details, crashArtifactWriter, testFilePath, }) => {
+    if (!crashArtifactWriter || !details.rawLines?.length) {
+        return details;
+    }
+    return {
+        ...details,
+        artifactPath: crashArtifactWriter.persistArtifact({
+            artifactKind: 'logcat',
+            testFilePath,
+            source: {
+                kind: 'text',
+                fileName: 'logcat.txt',
+                text: `${details.rawLines.join('\n')}\n`,
+            },
+        }),
+    };
+};
+const getDropboxFallbackDetails = (artifact) => ({
+    ...artifact,
+    artifactType: artifact.artifactType,
+    artifactPath: artifact.artifactPath,
+});
+const getEnrichmentArtifacts = async ({ bundleId, crashArtifactWriter, getDropboxOutput, getExitInfo, minOccurredAt, occurredAt, pid, testFilePath, }) => {
+    const dropboxArtifacts = getDropboxOutput
+        ? await waitForDropboxArtifacts({
+            bundleId,
+            crashArtifactWriter,
+            getDropboxOutput,
+            minOccurredAt,
+            occurredAt,
+            pid,
+            testFilePath,
+        })
+        : [];
+    const enrichmentArtifacts = dropboxArtifacts
+        .filter((artifact) => artifact.artifactPath !== undefined)
+        .map((artifact) => ({
+        artifactType: artifact.artifactType,
+        artifactPath: artifact.artifactPath,
+    }));
+    if (getExitInfo) {
+        const exitInfoArtifact = await collectExitInfoArtifact({
+            bundleId,
+            crashArtifactWriter,
+            getExitInfo,
+            pid,
+            testFilePath,
+        });
+        if (exitInfoArtifact?.artifactPath.startsWith('/')) {
+            enrichmentArtifacts.push({
+                artifactType: exitInfoArtifact.artifactType,
+                artifactPath: exitInfoArtifact.artifactPath,
+            });
+        }
+    }
+    return { dropboxArtifacts, enrichmentArtifacts };
+};
+export const createAndroidCrashReporter = ({ bundleId, crashArtifactWriter, getLogs, getDropboxOutput, getExitInfo, minOccurredAt, }) => ({
+    getCrashDetails: async ({ occurredAt, pid, testFilePath, }) => {
+        await new Promise((resolve) => setTimeout(resolve, CRASH_ARTIFACT_SETTLE_DELAY_MS));
+        const rawLines = getCrashBlock(getLogs(), occurredAt);
+        const logcatDetails = rawLines.length > 0
+            ? getLogcatCrashDetails({ rawLines, bundleId, pid })
+            : null;
+        let enrichmentArtifacts = [];
+        let dropboxArtifacts = [];
+        if (getDropboxOutput || getExitInfo) {
+            ({ dropboxArtifacts, enrichmentArtifacts } =
+                await getEnrichmentArtifacts({
+                    bundleId,
+                    crashArtifactWriter,
+                    getDropboxOutput,
+                    getExitInfo,
+                    minOccurredAt,
+                    occurredAt,
+                    pid,
+                    testFilePath,
+                }));
+        }
+        if (logcatDetails && hasUsefulLogcatBlock(rawLines)) {
+            return {
+                ...persistLogcatArtifact({
+                    details: logcatDetails,
+                    crashArtifactWriter,
+                    testFilePath,
+                }),
+                enrichmentArtifacts: enrichmentArtifacts.length > 0 ? enrichmentArtifacts : undefined,
+            };
+        }
+        const dropboxFallback = getBestDropboxArtifact(dropboxArtifacts);
+        if (dropboxFallback) {
+            const primary = getDropboxFallbackDetails(dropboxFallback);
+            return {
+                ...primary,
+                enrichmentArtifacts: enrichmentArtifacts.filter((artifact) => artifact.artifactPath !== primary.artifactPath),
+            };
+        }
+        if (logcatDetails) {
+            return {
+                ...persistLogcatArtifact({
+                    details: logcatDetails,
+                    crashArtifactWriter,
+                    testFilePath,
+                }),
+                enrichmentArtifacts: enrichmentArtifacts.length > 0 ? enrichmentArtifacts : undefined,
+            };
+        }
+        return enrichmentArtifacts.length > 0
+            ? {
+                enrichmentArtifacts,
+            }
+            : null;
+    },
+});

package/dist/device-state.d.ts

@@ -0,0 +1,6 @@
+import type { DeviceStateController } from '@react-native-harness/platforms';
+export declare const createAndroidDeviceState: (options: {
+    adbId: string;
+    bundleId: string;
+}) => DeviceStateController;
+//# sourceMappingURL=device-state.d.ts.map

package/dist/device-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-state.d.ts","sourceRoot":"","sources":["../src/device-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EAEtB,MAAM,iCAAiC,CAAC;AA0HzC,eAAO,MAAM,wBAAwB,GAAI,SAAS;IAChD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,KAAG,qBAqFH,CAAC"}

package/dist/device-state.js

@@ -0,0 +1,142 @@
+import * as adb from './adb.js';
+const ANDROID_PERMISSION_ALIASES = {
+    bluetooth: [
+        'android.permission.BLUETOOTH_CONNECT',
+        'android.permission.BLUETOOTH_SCAN',
+    ],
+    calendar: [
+        'android.permission.READ_CALENDAR',
+        'android.permission.WRITE_CALENDAR',
+    ],
+    camera: ['android.permission.CAMERA'],
+    contacts: [
+        'android.permission.READ_CONTACTS',
+        'android.permission.WRITE_CONTACTS',
+    ],
+    location: [
+        'android.permission.ACCESS_FINE_LOCATION',
+        'android.permission.ACCESS_COARSE_LOCATION',
+    ],
+    mediaLibrary: [
+        'android.permission.READ_MEDIA_IMAGES',
+        'android.permission.READ_MEDIA_VIDEO',
+        'android.permission.READ_MEDIA_AUDIO',
+    ],
+    microphone: ['android.permission.RECORD_AUDIO'],
+    notifications: ['android.permission.POST_NOTIFICATIONS'],
+    phone: [
+        'android.permission.CALL_PHONE',
+        'android.permission.ANSWER_PHONE_CALLS',
+    ],
+    sms: [
+        'android.permission.READ_SMS',
+        'android.permission.RECEIVE_SMS',
+        'android.permission.SEND_SMS',
+    ],
+    storage: [
+        'android.permission.READ_EXTERNAL_STORAGE',
+        'android.permission.WRITE_EXTERNAL_STORAGE',
+    ],
+};
+const normalizePermissionName = (name) => {
+    return name.trim();
+};
+const resolvePermissions = async (options) => {
+    if (options.command.kind === 'permission-all') {
+        return adb.getDeclaredDangerousPermissions(options.adbId, options.bundleId);
+    }
+    const normalized = normalizePermissionName(options.command.permission);
+    const aliases = ANDROID_PERMISSION_ALIASES[normalized];
+    if (aliases) {
+        return aliases;
+    }
+    return [normalized];
+};
+const snapshotPermissions = async (options) => {
+    const granted = await Promise.all(options.permissions.map(async (permission) => {
+        const isGranted = await adb.isPermissionGranted(options.adbId, options.bundleId, permission);
+        return isGranted ? permission : null;
+    }));
+    return granted.filter((permission) => permission != null);
+};
+const applyPermissionSnapshot = async (options) => {
+    const grantedSet = new Set(options.snapshot.previousGranted);
+    const toGrant = options.snapshot.permissions.filter((permission) => grantedSet.has(permission));
+    const toRevoke = options.snapshot.permissions.filter((permission) => !grantedSet.has(permission));
+    if (toGrant.length > 0) {
+        await adb.setPermissions(options.adbId, options.bundleId, toGrant, 'grant', {
+            bestEffort: true,
+        });
+    }
+    if (toRevoke.length > 0) {
+        await adb.setPermissions(options.adbId, options.bundleId, toRevoke, 'reset', {
+            bestEffort: true,
+        });
+    }
+};
+export const createAndroidDeviceState = (options) => {
+    const outstandingMutations = new Map();
+    let mutationCounter = 0;
+    const rememberMutation = (snapshot) => {
+        const id = `android-permissions-${++mutationCounter}`;
+        const mutation = {
+            id,
+            snapshot,
+            revert: async () => {
+                await controller.permissions.revert(id);
+            },
+        };
+        outstandingMutations.set(id, mutation);
+        return mutation;
+    };
+    const controller = {
+        permissions: {
+            apply: async (command) => {
+                const permissions = await resolvePermissions({
+                    adbId: options.adbId,
+                    bundleId: options.bundleId,
+                    command,
+                });
+                if (permissions.length === 0) {
+                    return { mutation: null };
+                }
+                const previousGranted = await snapshotPermissions({
+                    adbId: options.adbId,
+                    bundleId: options.bundleId,
+                    permissions,
+                });
+                await adb.setPermissions(options.adbId, options.bundleId, permissions, command.decision, { bestEffort: command.kind === 'permission-all' });
+                const mutation = rememberMutation({
+                    kind: 'permission-set',
+                    permissions,
+                    previousGranted,
+                });
+                return { mutation };
+            },
+            revert: async (mutationId) => {
+                const mutation = outstandingMutations.get(mutationId);
+                if (!mutation) {
+                    return;
+                }
+                outstandingMutations.delete(mutationId);
+                await applyPermissionSnapshot({
+                    adbId: options.adbId,
+                    bundleId: options.bundleId,
+                    snapshot: mutation.snapshot,
+                });
+            },
+            resetOutstanding: async () => {
+                const mutations = [...outstandingMutations.values()].reverse();
+                outstandingMutations.clear();
+                for (const mutation of mutations) {
+                    await applyPermissionSnapshot({
+                        adbId: options.adbId,
+                        bundleId: options.bundleId,
+                        snapshot: mutation.snapshot,
+                    });
+                }
+            },
+        },
+    };
+    return controller;
+};

package/dist/instance.d.ts

@@ -2,5 +2,5 @@ import { type HarnessPlatformInitOptions, HarnessPlatformRunner } from '@react-n
 import type { Config as HarnessConfig } from '@react-native-harness/config';
 import { AndroidPlatformConfig } from './config.js';
 export declare const getAndroidEmulatorPlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
-export declare const getAndroidPhysicalDevicePlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig) => Promise<HarnessPlatformRunner>;
+export declare const getAndroidPhysicalDevicePlatformInstance: (config: AndroidPlatformConfig, harnessConfig: HarnessConfig, init?: HarnessPlatformInitOptions) => Promise<HarnessPlatformRunner>;
 //# sourceMappingURL=instance.d.ts.map

package/dist/instance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,0BAA0B,EAC/B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,EACL,qBAAqB,EAGtB,MAAM,aAAa,CAAC;AAgLrB,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CA2I/B,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,KAC3B,OAAO,CAAC,qBAAqB,CAsE/B,CAAC"}
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../src/instance.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,0BAA0B,EAC/B,qBAAqB,EACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAE5E,OAAO,EACL,qBAAqB,EAGtB,MAAM,aAAa,CAAC;AAuKrB,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,MAAM,0BAA0B,KAC/B,OAAO,CAAC,qBAAqB,CA8H/B,CAAC;AAEF,eAAO,MAAM,wCAAwC,GACnD,QAAQ,qBAAqB,EAC7B,eAAe,aAAa,EAC5B,OAAO,0BAA0B,KAChC,OAAO,CAAC,qBAAqB,CAyD/B,CAAC"}