agent-scenario-loop 0.1.0

package/dist/runner/example-android-live.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertAggregatePassed = assertAggregatePassed;
+exports.formatResult = formatResult;
+exports.assertNoRegressedComparisons = assertNoRegressedComparisons;
+exports.buildLiveRunId = buildLiveRunId;
+exports.buildSkippedInteractionProofs = buildSkippedInteractionProofs;
+exports.buildInteractionComparisonLane = buildInteractionComparisonLane;
+exports.isTrustedProfileRun = isTrustedProfileRun;
+exports.main = main;
+exports.normalizeRunSuffix = normalizeRunSuffix;
+exports.resolveAndroidSerial = resolveAndroidSerial;
+exports.runExampleAndroidLiveProof = runExampleAndroidLiveProof;
+exports.usage = usage;
+const fs = require('node:fs');
+const path = require('node:path');
+const { hasHelpFlag, writeUsage } = require('./cli');
+const { parsePositiveInteger, parseArgs, runAndroidAdbPreflight, } = require('./android-adb');
+const { compareLiveProfilesToLatest, isEnabledFlag, } = require('./live-comparison');
+const { writeLiveProofSummary } = require('./live-proof-summary');
+const { runAgentDeviceCapture } = require('./agent-device');
+const { parseBaseArgs: parseArgentBaseArgs, runArgentCapture } = require('./argent');
+const { loadAslLocalEnv, readStringArgOrEnv } = require('./local-env');
+const { runProfileAndroid } = require('./profile-android');
+const EXAMPLE_PROFILES = [
+    {
+        label: 'startup',
+        runId: 'android-live-startup',
+        scenario: 'app-startup.json',
+        scenarioId: 'app-startup',
+    },
+    {
+        label: 'open-close',
+        runId: 'android-live-open-close',
+        scenario: 'open-close-cycle.json',
+        scenarioId: 'open-close-cycle',
+    },
+    {
+        label: 'scroll',
+        runId: 'android-live-scroll',
+        scenario: 'scroll-settle.json',
+        scenarioId: 'scroll-settle',
+    },
+];
+const DEFAULT_REACT_NATIVE_DEBUG_HOST = 'localhost:8097';
+/**
+ * Prints CLI usage.
+ *
+ * @param {{write: (message: string) => unknown}} [output]
+ * @returns {void}
+ */
+function usage(output = process.stderr) {
+    writeUsage([
+        'Usage: asl-example-android-live [--config <path>] [--out <dir>] [--package <name>] [--serial <device>] [--react-native-debug-host <host:port>] [--run-suffix <label>] [--compare-latest] [--fail-on-regression] [--agent-device-proof] [--argent-proof]',
+        '',
+        'Runs the packaged example Android live proof: adb preflight, startup, open-close, and scroll-settle.',
+        'The example app must already be installed and reachable on an online Android emulator or device.',
+        `By default, the runner sets the app React Native debug host to ${DEFAULT_REACT_NATIVE_DEBUG_HOST} for the isolated Metro server.`,
+        'Use --run-suffix to preserve multiple live proof artifact sets without changing deterministic default run ids.',
+        'Use --compare-latest to compare each passed scenario against the latest trusted prior run under the artifact root.',
+        'Use --fail-on-regression with --compare-latest to exit nonzero after writing evidence when any comparison regressed.',
+        'Use --agent-device-proof to attach the shared startup UI assertion through agent-device; pass --agent-device-session-mode bind when a named session should still receive the configured serial.',
+        'Use --argent-proof to attach the shared startup UI assertion through Argent; set ASL_ARGENT_BIN and ASL_ARGENT_BASE_ARGS for non-global installs.',
+    ], output);
+}
+/**
+ * Resolves the package root for source and built CLI execution.
+ *
+ * @returns {string}
+ */
+function defaultPackageRoot() {
+    return path.resolve(__dirname, '..', '..');
+}
+/**
+ * Reads a JSON object from disk.
+ *
+ * @param {string} filePath
+ * @returns {Record<string, unknown>}
+ */
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+/**
+ * Reads a nested object property from unknown JSON.
+ *
+ * @param {Record<string, unknown>} value
+ * @param {string} key
+ * @returns {Record<string, unknown> | null}
+ */
+function readObjectProperty(value, key) {
+    const property = value[key];
+    return property && typeof property === 'object' && !Array.isArray(property)
+        ? property
+        : null;
+}
+/**
+ * Resolves the Android package name from explicit input or ASL config.
+ *
+ * @param {{args: CliArgs, config: Record<string, unknown>}} options
+ * @returns {string | null}
+ */
+function resolveAndroidPackageName({ args, config, }) {
+    if (typeof args.package === 'string') {
+        return args.package;
+    }
+    const app = readObjectProperty(config, 'app');
+    return typeof app?.androidPackage === 'string' ? app.androidPackage : null;
+}
+/**
+ * Resolves the Android target used by every example proof lane.
+ *
+ * @param {CliArgs} args
+ * @returns {string}
+ */
+function resolveAndroidSerial(args) {
+    return readStringArgOrEnv(args.serial, ['ASL_ANDROID_SERIAL', 'ASL_EXAMPLE_ANDROID_SERIAL']) ?? 'emulator-5554';
+}
+/**
+ * Converts a caller-provided run suffix into a path-safe run-id segment.
+ *
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+function normalizeRunSuffix(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/gu, '-')
+        .replace(/^-+|-+$/gu, '')
+        .slice(0, 64);
+    return normalized.length > 0 ? normalized : null;
+}
+/**
+ * Applies the optional run suffix while preserving deterministic defaults.
+ *
+ * @param {string} baseRunId
+ * @param {string | null} suffix
+ * @returns {string}
+ */
+function buildLiveRunId(baseRunId, suffix) {
+    return suffix ? `${baseRunId}-${suffix}` : baseRunId;
+}
+/**
+ * Builds the comparison lane suffix for enabled interaction proofs.
+ *
+ * @param {string[]} runnerIds
+ * @returns {string}
+ */
+function buildInteractionComparisonLane(runnerIds) {
+    return runnerIds.length > 0
+        ? `example-android-live+${runnerIds.join('+')}`
+        : 'example-android-live';
+}
+/**
+ * Reports whether profile evidence is healthy enough to trust sidecar proofs and comparisons.
+ *
+ * @param {{health: Record<string, unknown>, verdict: Record<string, unknown>}} run
+ * @returns {boolean}
+ */
+function isTrustedProfileRun({ health, verdict, }) {
+    return health.healthStatus === 'passed' && verdict.verdictStatus === 'passed';
+}
+/**
+ * Builds skipped sidecar pointers for requested example runners when the profile batch failed.
+ *
+ * @param {{failedProfiles: AndroidLiveProfile[], requestedRunners: string[], runIdsByRunner: Record<string, string>}} options
+ * @returns {AndroidSkippedInteractionProof[]}
+ */
+function buildSkippedInteractionProofs({ failedProfiles, requestedRunners, runIdsByRunner, }) {
+    if (failedProfiles.length === 0) {
+        return [];
+    }
+    const failedSummary = failedProfiles
+        .map((profile) => `${profile.label}=health:${profile.healthStatus ?? 'unknown'}/verdict:${profile.verdictStatus ?? 'unknown'}`)
+        .join(', ');
+    const reason = `Profile batch failed (${failedSummary}); sidecar interaction proof was skipped because aggregate runner evidence would not be trustworthy.`;
+    const labelsByRunner = {
+        'agent-device': 'startup-ui',
+        argent: 'startup-ui-argent',
+    };
+    return requestedRunners.map((runnerId) => ({
+        label: labelsByRunner[runnerId] ?? `startup-ui-${runnerId}`,
+        nextAction: {
+            code: 'fix_profile_gate',
+            summary: 'Inspect the failed profile health and verdict before rerunning sidecar interaction proofs.',
+        },
+        reason,
+        runId: runIdsByRunner[runnerId] ?? `android-${runnerId}-startup`,
+        runnerId,
+        scenarioId: 'app-startup',
+    }));
+}
+/**
+ * Throws after aggregate proof writing when the live proof itself failed.
+ *
+ * @param {AndroidLiveProofResult} result
+ * @returns {void}
+ */
+function assertAggregatePassed(result) {
+    const proof = readJson(result.aggregateSummary.liveProofPath);
+    if (proof.status === 'passed') {
+        return;
+    }
+    throw new Error(`Android example live proof failed. Inspect ${result.aggregateSummary.summaryPath}.`);
+}
+/**
+ * Throws after aggregate proof writing when fail-on-regression should gate the run.
+ *
+ * @param {RegressionGateOptions} options
+ * @returns {void}
+ */
+function assertNoRegressedComparisons({ platformLabel, result, }) {
+    const regressed = result.comparisons.filter((comparison) => comparison.status === 'worse');
+    if (regressed.length === 0) {
+        return;
+    }
+    const labels = regressed.map((comparison) => comparison.label).join(', ');
+    throw new Error(`${platformLabel} example live proof found regressed comparison(s): ${labels}. Inspect ${result.aggregateSummary.summaryPath}.`);
+}
+/**
+ * Runs adb preflight plus all canonical Android example live profiles.
+ *
+ * @param {CliArgs} args
+ * @param {AndroidLiveProofOptions} [options]
+ * @returns {Promise<AndroidLiveProofResult>}
+ */
+async function runExampleAndroidLiveProof(args, options = {}) {
+    const packageRoot = options.packageRoot ?? defaultPackageRoot();
+    const exampleRoot = path.join(packageRoot, 'examples', 'mobile-app');
+    const configPath = typeof args.config === 'string'
+        ? path.resolve(args.config)
+        : path.join(exampleRoot, 'asl.config.json');
+    const outputDir = typeof args.out === 'string'
+        ? path.resolve(args.out)
+        : path.resolve('artifacts/example-mobile-app/android');
+    const config = readJson(configPath);
+    const packageName = resolveAndroidPackageName({ args, config });
+    const serial = resolveAndroidSerial(args);
+    const agentDeviceSession = readStringArgOrEnv(args['agent-device-session'], [
+        'ASL_ANDROID_AGENT_DEVICE_SESSION',
+        'ASL_EXAMPLE_ANDROID_AGENT_DEVICE_SESSION',
+    ]);
+    const agentDeviceSessionMode = readStringArgOrEnv(args['agent-device-session-mode'], [
+        'ASL_ANDROID_AGENT_DEVICE_SESSION_MODE',
+        'ASL_EXAMPLE_ANDROID_AGENT_DEVICE_SESSION_MODE',
+    ]);
+    const runSuffix = normalizeRunSuffix(args['run-suffix']);
+    const aggregateRunId = buildLiveRunId('android-live-proof', runSuffix);
+    const preflightRunId = buildLiveRunId('android-live-preflight', runSuffix);
+    const agentDeviceRunId = buildLiveRunId('android-agent-device-startup', runSuffix);
+    const argentRunId = buildLiveRunId('android-argent-startup', runSuffix);
+    const enabledInteractionRunners = [
+        ...(isEnabledFlag(args['agent-device-proof']) ? ['agent-device'] : []),
+        ...(isEnabledFlag(args['argent-proof']) ? ['argent'] : []),
+    ];
+    const comparisonLane = buildInteractionComparisonLane(enabledInteractionRunners);
+    const runIdsByRunner = {
+        'agent-device': agentDeviceRunId,
+        argent: argentRunId,
+    };
+    const preflightDir = path.join(outputDir, '_preflight', preflightRunId);
+    const reactNativeDebugHost = typeof args['react-native-debug-host'] === 'string'
+        ? args['react-native-debug-host']
+        : DEFAULT_REACT_NATIVE_DEBUG_HOST;
+    const preflight = await runAndroidAdbPreflight({
+        ...(typeof args.adb === 'string' ? { adbPath: args.adb } : {}),
+        ...(options.delay ? { delay: options.delay } : {}),
+        ...(options.executor ? { executor: options.executor } : {}),
+        outputDir: preflightDir,
+        packageName,
+        reactNativeDebugHost,
+        runId: preflightRunId,
+        serial,
+    });
+    if (preflight.health.healthStatus !== 'passed') {
+        throw new Error(`Android live proof preflight failed; inspect ${preflight.runDir}/agent-summary.md.`);
+    }
+    const interactionProofs = [];
+    const profiles = [];
+    const failedProfiles = [];
+    for (const profile of EXAMPLE_PROFILES) {
+        const profileRunId = buildLiveRunId(profile.runId, runSuffix);
+        const result = await runProfileAndroid({
+            ...(typeof args.adb === 'string' ? { adb: args.adb } : {}),
+            'adb-capture': true,
+            'clear-logcat': true,
+            config: configPath,
+            'command-wait-ms': typeof args['command-wait-ms'] === 'string' ? args['command-wait-ms'] : '250',
+            launch: true,
+            'launch-wait-ms': typeof args['launch-wait-ms'] === 'string' ? args['launch-wait-ms'] : '1500',
+            'logcat-lines': typeof args['logcat-lines'] === 'string' ? args['logcat-lines'] : '1000',
+            out: outputDir,
+            ...(packageName ? { package: packageName } : {}),
+            'profile-session': true,
+            'react-native-debug-host': reactNativeDebugHost,
+            'run-id': profileRunId,
+            scenario: path.join(exampleRoot, 'scenarios', 'mobile', profile.scenario),
+            serial,
+            'wait-ms': typeof args['wait-ms'] === 'string' ? args['wait-ms'] : '1000',
+        }, {
+            comparisonLane,
+            ...(options.delay ? { delay: options.delay } : {}),
+            ...(options.executor ? { executor: options.executor } : {}),
+        });
+        const profilePointer = {
+            healthStatus: typeof result.health.healthStatus === 'string' ? result.health.healthStatus : 'unknown',
+            label: profile.label,
+            runDir: result.runDir,
+            runId: profileRunId,
+            scenario: profile.scenario,
+            scenarioId: profile.scenarioId,
+            verdictStatus: typeof result.verdict.verdictStatus === 'string' ? result.verdict.verdictStatus : 'unknown',
+        };
+        profiles.push(profilePointer);
+        if (!isTrustedProfileRun({ health: result.health, verdict: result.verdict })) {
+            failedProfiles.push(profilePointer);
+        }
+    }
+    const skippedInteractionProofs = buildSkippedInteractionProofs({
+        failedProfiles,
+        requestedRunners: enabledInteractionRunners,
+        runIdsByRunner,
+    });
+    const profileBatchTrusted = failedProfiles.length === 0;
+    if (profileBatchTrusted && isEnabledFlag(args['agent-device-proof'])) {
+        const agentDeviceCapture = await runAgentDeviceCapture({
+            ...(typeof args['agent-device'] === 'string' ? { agentDevicePath: args['agent-device'] } : {}),
+            app: packageName,
+            ...(options.agentDeviceExecutor ? { executor: options.agentDeviceExecutor } : {}),
+            open: true,
+            outputDir: path.join(outputDir, '_agent-device-captures', agentDeviceRunId),
+            platform: 'android',
+            runId: agentDeviceRunId,
+            scenario: readJson(path.join(exampleRoot, 'scenarios', 'mobile', 'app-startup.json')),
+            serial,
+            ...(agentDeviceSession ? { session: agentDeviceSession } : {}),
+            ...(agentDeviceSessionMode
+                ? { sessionMode: agentDeviceSessionMode }
+                : {}),
+            waitMs: parsePositiveInteger(args['agent-device-wait-ms'], 1000),
+        });
+        interactionProofs.push({
+            label: 'startup-ui',
+            runDir: agentDeviceCapture.runDir,
+            runId: agentDeviceRunId,
+            runnerId: 'agent-device',
+            scenarioId: 'app-startup',
+        });
+    }
+    if (profileBatchTrusted && isEnabledFlag(args['argent-proof'])) {
+        const argentBaseArgs = parseArgentBaseArgs(process.env.ASL_ARGENT_BASE_ARGS);
+        const argentCapture = await runArgentCapture({
+            app: packageName,
+            argentCommand: process.env.ASL_ARGENT_BIN || 'argent',
+            ...(argentBaseArgs ? { baseArgs: argentBaseArgs } : {}),
+            commandTimeoutMs: parsePositiveInteger(process.env.ASL_ARGENT_COMMAND_TIMEOUT_MS, 60_000),
+            deviceId: serial,
+            ...(options.delay ? { delay: options.delay } : {}),
+            ...(options.argentExecutor ? { executor: options.argentExecutor } : {}),
+            outputDir: path.join(outputDir, '_argent-captures', argentRunId),
+            platform: 'android',
+            runId: argentRunId,
+            scenario: readJson(path.join(exampleRoot, 'scenarios', 'mobile', 'app-startup.json')),
+        });
+        interactionProofs.push({
+            label: 'startup-ui-argent',
+            runDir: argentCapture.runDir,
+            runId: argentRunId,
+            runnerId: 'argent',
+            scenarioId: 'app-startup',
+        });
+    }
+    const comparisons = profileBatchTrusted && isEnabledFlag(args['compare-latest'])
+        ? await compareLiveProfilesToLatest({ outputDir, profiles })
+        : [];
+    const aggregateSummary = await writeLiveProofSummary({
+        comparisons,
+        interactionProofs,
+        outputDir,
+        platform: 'android',
+        preflightDir: preflight.runDir,
+        preflightRunId,
+        profiles,
+        runId: aggregateRunId,
+        skippedInteractionProofs,
+    });
+    const result = {
+        aggregateSummary,
+        comparisons,
+        interactionProofs,
+        outputDir,
+        preflightDir: preflight.runDir,
+        profiles,
+        skippedInteractionProofs,
+    };
+    if (isEnabledFlag(args['fail-on-regression'])) {
+        assertNoRegressedComparisons({
+            platformLabel: 'Android',
+            result,
+        });
+    }
+    assertAggregatePassed(result);
+    return result;
+}
+/**
+ * Formats the live proof result for humans and agents.
+ *
+ * @param {AndroidLiveProofResult} result
+ * @returns {string}
+ */
+function formatResult(result) {
+    return [
+        'Android example live proof passed.',
+        `Live proof: ${result.aggregateSummary.summaryPath}`,
+        `Preflight: ${result.preflightDir}/agent-summary.md`,
+        ...result.profiles.map((profile) => (`${profile.label}: ${profile.runDir}/agent-summary.md`)),
+        ...result.interactionProofs.map((proof) => (`${proof.label}: ${proof.runDir}/agent-summary.md`)),
+        ...(result.comparisons.length > 0
+            ? [
+                'Comparisons:',
+                ...result.comparisons.map((comparison) => (comparison.status === 'skipped'
+                    ? `${comparison.label}: skipped - ${comparison.reason}`
+                    : `${comparison.label}: ${comparison.status} ${comparison.summaryPath}`)),
+            ]
+            : []),
+        `Artifact root: ${result.outputDir}`,
+    ].join('\n');
+}
+/**
+ * Runs the example Android live proof CLI.
+ *
+ * @returns {Promise<void>}
+ */
+async function main() {
+    const argv = process.argv.slice(2);
+    if (hasHelpFlag(argv)) {
+        usage(process.stdout);
+        return;
+    }
+    loadAslLocalEnv();
+    const args = parseArgs(argv);
+    const result = await runExampleAndroidLiveProof(args);
+    process.stdout.write(`${formatResult(result)}\n`);
+}
+if (require.main === module) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}

package/dist/runner/example-ios-live.d.ts

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+type CliArgs = import('./ios-simctl').CliArgs;
+type LiveComparisonResult = import('./live-comparison').LiveComparisonResult;
+type LiveProofSummaryResult = import('./live-proof-summary').LiveProofSummaryResult;
+type IosLiveProofOptions = {
+    agentDeviceExecutor?: import('./agent-device').CommandExecutor;
+    argentExecutor?: import('./argent').CommandExecutor;
+    delay?: (ms: number) => Promise<void>;
+    executor?: import('./ios-simctl').CommandExecutor;
+    packageRoot?: string;
+};
+type IosInteractionProof = {
+    label: string;
+    runDir: string;
+    runId: string;
+    runnerId: string;
+    scenarioId: string;
+};
+type IosSkippedInteractionProof = import('./live-proof-summary').LiveProofSkippedInteractionProofPointer;
+type IosLiveProfile = {
+    healthStatus?: string;
+    label: string;
+    runDir: string;
+    runId: string;
+    scenario: string;
+    scenarioId: string;
+    verdictStatus?: string;
+};
+type IosLiveProofResult = {
+    aggregateSummary: LiveProofSummaryResult;
+    comparisons: LiveComparisonResult[];
+    interactionProofs: IosInteractionProof[];
+    outputDir: string;
+    preflightDir: string;
+    profiles: IosLiveProfile[];
+    skippedInteractionProofs: IosSkippedInteractionProof[];
+};
+type RegressionGateOptions = {
+    platformLabel: string;
+    result: IosLiveProofResult;
+};
+/**
+ * Prints CLI usage.
+ *
+ * @param {{write: (message: string) => unknown}} [output]
+ * @returns {void}
+ */
+declare function usage(output?: {
+    write: (message: string) => unknown;
+}): void;
+/**
+ * Resolves the simulator target used by every iOS proof lane.
+ *
+ * @param {CliArgs} args
+ * @returns {string}
+ */
+declare function resolveIosDeviceId(args: CliArgs): string;
+/**
+ * Converts a caller-provided run suffix into a path-safe run-id segment.
+ *
+ * @param {unknown} value
+ * @returns {string | null}
+ */
+declare function normalizeRunSuffix(value: unknown): string | null;
+/**
+ * Applies the optional run suffix while preserving deterministic defaults.
+ *
+ * @param {string} baseRunId
+ * @param {string | null} suffix
+ * @returns {string}
+ */
+declare function buildLiveRunId(baseRunId: string, suffix: string | null): string;
+/**
+ * Builds the comparison lane suffix for enabled interaction proofs.
+ *
+ * @param {string[]} runnerIds
+ * @returns {string}
+ */
+declare function buildInteractionComparisonLane(runnerIds: string[]): string;
+/**
+ * Reports whether profile evidence is healthy enough to trust sidecar proofs and comparisons.
+ *
+ * @param {{health: Record<string, unknown>, verdict: Record<string, unknown>}} run
+ * @returns {boolean}
+ */
+declare function isTrustedProfileRun({ health, verdict, }: {
+    health: Record<string, unknown>;
+    verdict: Record<string, unknown>;
+}): boolean;
+/**
+ * Builds skipped sidecar pointers for requested example runners when the profile batch failed.
+ *
+ * @param {{failedProfiles: IosLiveProfile[], requestedRunners: string[], runIdsByRunner: Record<string, string>}} options
+ * @returns {IosSkippedInteractionProof[]}
+ */
+declare function buildSkippedInteractionProofs({ failedProfiles, requestedRunners, runIdsByRunner, }: {
+    failedProfiles: IosLiveProfile[];
+    requestedRunners: string[];
+    runIdsByRunner: Record<string, string>;
+}): IosSkippedInteractionProof[];
+/**
+ * Throws after aggregate proof writing when the live proof itself failed.
+ *
+ * @param {IosLiveProofResult} result
+ * @returns {void}
+ */
+declare function assertAggregatePassed(result: IosLiveProofResult): void;
+/**
+ * Throws after aggregate proof writing when fail-on-regression should gate the run.
+ *
+ * @param {RegressionGateOptions} options
+ * @returns {void}
+ */
+declare function assertNoRegressedComparisons({ platformLabel, result, }: RegressionGateOptions): void;
+/**
+ * Runs simctl preflight plus all canonical iOS example live profiles.
+ *
+ * @param {CliArgs} args
+ * @param {IosLiveProofOptions} [options]
+ * @returns {Promise<IosLiveProofResult>}
+ */
+declare function runExampleIosLiveProof(args: CliArgs, options?: IosLiveProofOptions): Promise<IosLiveProofResult>;
+/**
+ * Formats the live proof result for humans and agents.
+ *
+ * @param {IosLiveProofResult} result
+ * @returns {string}
+ */
+declare function formatResult(result: IosLiveProofResult): string;
+/**
+ * Runs the example iOS live proof CLI.
+ *
+ * @returns {Promise<void>}
+ */
+declare function main(): Promise<void>;
+export { assertAggregatePassed, buildLiveRunId, formatResult, assertNoRegressedComparisons, buildSkippedInteractionProofs, buildInteractionComparisonLane, isTrustedProfileRun, main, normalizeRunSuffix, resolveIosDeviceId, runExampleIosLiveProof, usage, };
+export type { IosLiveProofOptions, IosInteractionProof, IosLiveProofResult, IosLiveProfile, };