@expo-harmony/cli 55.0.26-harmony.1 → 55.0.26-harmony.2

package/build/args.d.ts

@@ -0,0 +1,19 @@
+type Option = {
+    short?: string;
+    type: 'boolean' | 'string';
+};
+type Options = Record<string, Option>;
+type Values<T extends Options> = {
+    [K in keyof T]?: T[K]['type'] extends 'boolean' ? boolean : string;
+};
+declare const CommonOptions: {
+    readonly help: {
+        readonly short: "h";
+        readonly type: "boolean";
+    };
+};
+declare function parseArgs<T extends Options>(options: T, argv: string[]): {
+    positionals: string[];
+    values: Values<T>;
+};
+export { CommonOptions, parseArgs };

package/build/args.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonOptions = void 0;
+exports.parseArgs = parseArgs;
+const node_util_1 = require("node:util");
+const errors_1 = require("./errors");
+const CommonOptions = {
+    help: { short: 'h', type: 'boolean' },
+};
+exports.CommonOptions = CommonOptions;
+function parseArgs(options, argv) {
+    try {
+        return (0, node_util_1.parseArgs)({
+            allowPositionals: true,
+            args: argv,
+            options,
+            strict: true,
+        });
+    }
+    catch (cause) {
+        const message = cause instanceof Error ? cause.message : String(cause);
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', message, {
+            cause,
+            operation: 'parse-arguments',
+        });
+    }
+}

package/build/bin/expo-harmony.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/buildHap/build.d.ts

@@ -0,0 +1,25 @@
+export interface HarmonyBuildOptions {
+    io?: Pick<Console, 'error' | 'log' | 'warn'>;
+    /** @internal For release verification after a successful isolated prebuild check. */
+    skipGeneratedProjectCheck?: boolean;
+    sync?: boolean;
+    variant?: 'debug' | 'release';
+}
+export interface HarmonyBuildResult {
+    bundleName: string;
+    export: null | {
+        assetCount: number;
+        bundleSha256: string;
+        sourceMapSha256: string;
+    };
+    hapPath: string;
+    headless: true;
+    installed: false;
+    launched: false;
+    ok: true;
+    schemaVersion: 1;
+    steps: Record<string, number>;
+    variant: 'debug' | 'release';
+}
+declare function buildHarmonyAsync(projectRoot: string, options?: HarmonyBuildOptions): Promise<HarmonyBuildResult>;
+export { buildHarmonyAsync };

package/build/buildHap/build.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildHarmonyAsync = buildHarmonyAsync;
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("../errors");
+const export_1 = require("../exportEmbed/export");
+const path_1 = require("../path");
+const projectLock_1 = require("../projectLock");
+const cache_1 = require("../run/cache");
+const install_1 = require("../run/install");
+const tools_1 = require("../tools");
+const common_1 = require("./common");
+async function buildHarmonyUnlockedAsync(projectRoot, options = {}) {
+    const normalizedOptions = {
+        io: options.io || console,
+        requireDeviceTools: false,
+        skipGeneratedProjectCheck: Boolean(options.skipGeneratedProjectCheck),
+        sync: Boolean(options.sync),
+        variant: options.variant || 'debug',
+    };
+    const steps = {
+        device: 0,
+        install: 0,
+        launch: 0,
+        metro: 0,
+        metroPort: 0,
+    };
+    await (0, common_1.ensureGeneratedProjectAsync)(projectRoot, normalizedOptions, steps);
+    const plan = await (0, common_1.timed)(steps, 'buildPlan', () => (0, tools_1.resolveHarmonyBuildPlanAsync)(projectRoot, { buildMode: normalizedOptions.variant }));
+    const toolchain = (0, tools_1.resolveHarmonyToolchain)();
+    let exportManifest = null;
+    if (normalizedOptions.variant === 'release') {
+        (0, common_1.progress)(normalizedOptions, 'Exporting the release Hermes bundle');
+        exportManifest = await (0, common_1.timed)(steps, 'export', () => (0, export_1.exportEmbedAsync)(projectRoot, { skipDoctor: true }));
+    }
+    else {
+        steps.export = 0;
+    }
+    (0, common_1.progress)(normalizedOptions, 'Installing Harmony project dependencies');
+    await (0, common_1.timed)(steps, 'ohpm', () => (0, install_1.installHarmonyDependenciesAsync)(plan, toolchain));
+    (0, common_1.progress)(normalizedOptions, 'Checking Harmony native dependency cache');
+    const nativeBuildCache = await (0, common_1.timed)(steps, 'nativeCache', () => ((0, cache_1.prepareHarmonyNativeBuildCacheAsync)(projectRoot, plan)));
+    if (nativeBuildCache.changed) {
+        (0, common_1.progress)(normalizedOptions, 'Invalidated stale Harmony native build objects');
+    }
+    (0, common_1.progress)(normalizedOptions, `Building the ${normalizedOptions.variant} HAP without a device`);
+    const buildEnv = {
+        ...process.env,
+        EXPO_HARMONY_NODE: process.env.EXPO_HARMONY_NODE || process.execPath,
+        EXPO_METRO_TARGET: 'harmony',
+        HERMES_V1_ENABLED: 'true',
+        ...(normalizedOptions.variant === 'release' ? { EXPO_HARMONY_BUNDLE_PREBUILT: '1' } : {}),
+        ...(toolchain.sdkHome && !process.env.DEVECO_SDK_HOME
+            ? { DEVECO_SDK_HOME: toolchain.sdkHome }
+            : {}),
+    };
+    await (0, common_1.timed)(steps, 'build', () => (0, common_1.runCheckedAsync)(toolchain.hvigor.command, [
+        ...toolchain.hvigor.args,
+        ...plan.hvigorArgs,
+    ], {
+        code: 'ERR_HARMONY_BUILD_FAILED',
+        cwd: plan.harmonyRoot,
+        env: buildEnv,
+        message: 'Hvigor build',
+        operation: 'hvigor-build',
+        timeoutMs: 15 * 60_000,
+    }));
+    if (!(0, common_1.isNonEmptyRegularFile)(plan.expectedHap)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_HAP_MISSING', 'Hvigor completed without producing the expected non-empty regular HAP.', { operation: 'verify-hap' });
+    }
+    await (0, common_1.timed)(steps, 'nativeCacheCommit', () => (0, cache_1.commitHarmonyNativeBuildCacheAsync)(nativeBuildCache));
+    return {
+        bundleName: plan.bundleName,
+        export: exportManifest
+            ? {
+                assetCount: exportManifest.assets.length,
+                bundleSha256: exportManifest.bundle.sha256,
+                sourceMapSha256: exportManifest.sourceMap.sha256,
+            }
+            : null,
+        hapPath: (0, path_1.toPosixPath)(node_path_1.default.relative(projectRoot, plan.expectedHap)),
+        headless: true,
+        installed: false,
+        launched: false,
+        ok: true,
+        schemaVersion: 1,
+        steps,
+        variant: normalizedOptions.variant,
+    };
+}
+async function buildHarmonyAsync(projectRoot, options = {}) {
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(projectRoot, 'build', () => buildHarmonyUnlockedAsync(projectRoot, options));
+}

package/build/buildHap/common.d.ts

@@ -0,0 +1,24 @@
+interface HarmonyBuildPipelineOptions {
+    io?: Pick<Console, 'error' | 'log' | 'warn'>;
+    requireDeviceTools?: boolean;
+    /** @internal The caller already completed an isolated prebuild check. */
+    skipGeneratedProjectCheck?: boolean;
+    sync: boolean;
+    variant: 'debug' | 'release';
+}
+interface CheckedProcessOptions {
+    code: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    message: string;
+    operation: string;
+    outputLimit?: number;
+    timeoutMs?: number;
+}
+declare function progress(options: HarmonyBuildPipelineOptions, message: string): void;
+declare function timed<T>(steps: Record<string, number>, name: string, operation: () => Promise<T> | T): Promise<T>;
+declare function isNonEmptyRegularFile(file: string): boolean;
+declare function runCheckedAsync(command: string, args: string[], options: CheckedProcessOptions): Promise<import("../process").ProcessResult>;
+declare function ensureGeneratedProjectAsync(projectRoot: string, options: HarmonyBuildPipelineOptions, steps: Record<string, number>): Promise<void>;
+export { ensureGeneratedProjectAsync, isNonEmptyRegularFile, progress, runCheckedAsync, timed, };
+export type { CheckedProcessOptions, HarmonyBuildPipelineOptions };

package/build/buildHap/common.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureGeneratedProjectAsync = ensureGeneratedProjectAsync;
+exports.isNonEmptyRegularFile = isNonEmptyRegularFile;
+exports.progress = progress;
+exports.runCheckedAsync = runCheckedAsync;
+exports.timed = timed;
+const node_fs_1 = __importDefault(require("node:fs"));
+const doctor_1 = require("../doctor/doctor");
+const errors_1 = require("../errors");
+const check_1 = require("../prebuild/check");
+const prebuild_1 = require("../prebuild/prebuild");
+const process_1 = require("../process");
+const tools_1 = require("../tools");
+function progress(options, message) {
+    options.io?.log?.(`› ${message}`);
+}
+async function timed(steps, name, operation) {
+    const started = performance.now();
+    try {
+        return await operation();
+    }
+    finally {
+        steps[name] = Math.max(0, Math.round(performance.now() - started));
+    }
+}
+function assertDoctor(result) {
+    if (result.ok)
+        return;
+    const failing = result.checks.filter(check => check.status === 'error').map(check => check.id);
+    throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', `Harmony doctor found blocking checks: ${failing.join(', ') || 'unknown'}.`, { operation: 'doctor' });
+}
+function isNonEmptyRegularFile(file) {
+    try {
+        const stat = node_fs_1.default.lstatSync(file);
+        return !stat.isSymbolicLink() && stat.isFile() && stat.size > 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function runCheckedAsync(command, args, options) {
+    const result = await (0, process_1.spawnAsync)(command, args, {
+        capture: true,
+        cwd: options.cwd,
+        env: options.env,
+        operation: options.operation,
+        outputLimit: options.outputLimit || 2 * 1024 * 1024,
+        timeoutMs: options.timeoutMs,
+    });
+    if (result.code !== 0 || result.timedOut) {
+        const diagnostics = (0, process_1.formatDiagnostics)(result);
+        throw new errors_1.HarmonyCliError(options.code, `${options.message} exited with code ${result.code}${result.timedOut ? ' after timing out' : ''}.${diagnostics ? `\n${diagnostics}` : ''}`, { exitCode: result.code || 1, operation: options.operation });
+    }
+    return result;
+}
+async function ensureGeneratedProjectAsync(projectRoot, options, steps) {
+    const plan = await (0, tools_1.resolveHarmonyBuildPlanIfPresentAsync)(projectRoot, {
+        buildMode: options.variant,
+    });
+    const exists = Boolean(plan && node_fs_1.default.existsSync(plan.harmonyRoot));
+    progress(options, 'Checking the Harmony project');
+    const doctor = await timed(steps, 'doctor', () => (0, doctor_1.doctorAsync)(projectRoot, {
+        requireBuildTools: true,
+        requireDeviceTools: options.requireDeviceTools,
+        validateGeneratedProject: exists,
+        validateModules: false,
+    }));
+    assertDoctor(doctor);
+    if (!exists || options.sync) {
+        progress(options, exists
+            ? 'Synchronizing the generated Harmony project'
+            : 'Generating the missing Harmony project');
+        await timed(steps, 'prebuild', () => (0, prebuild_1.prebuildParsedAsync)(projectRoot, [], { buildType: options.variant }));
+        steps.cngCheck = 0;
+        return;
+    }
+    steps.prebuild = 0;
+    if (options.skipGeneratedProjectCheck) {
+        steps.cngCheck = 0;
+        return;
+    }
+    progress(options, 'Checking CNG ownership and drift');
+    const check = await timed(steps, 'cngCheck', () => (0, check_1.checkAsync)(projectRoot, { buildType: options.variant }));
+    if (!check.clean) {
+        const summary = check.changes.slice(0, 8).map(change => `${change.type}:${change.path}`).join(', ');
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_MANIFEST_DRIFT', `Generated Harmony files differ from CNG desired state${summary ? ` (${summary})` : ''}. Run expo-harmony prebuild or retry with --sync.`, { operation: 'check' });
+    }
+}

package/build/buildHap/options.d.ts

@@ -0,0 +1,7 @@
+declare function parseBuildArgs(argv: string[]): {
+    help: boolean;
+    project: string;
+    sync: boolean;
+    variant: "debug" | "release";
+};
+export { parseBuildArgs };

package/build/buildHap/options.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBuildArgs = parseBuildArgs;
+const args_1 = require("../args");
+const errors_1 = require("../errors");
+const BuildOptions = {
+    ...args_1.CommonOptions,
+    sync: { type: 'boolean' },
+    variant: { type: 'string' },
+};
+function parseBuildArgs(argv) {
+    const { positionals, values } = (0, args_1.parseArgs)(BuildOptions, argv);
+    if (positionals.length > 1) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unexpected build positional argument: ${positionals[1]}`, {
+            operation: 'parse-arguments',
+        });
+    }
+    const variant = values.variant || 'debug';
+    if (variant !== 'debug' && variant !== 'release') {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--variant must be debug or release.', {
+            operation: 'parse-arguments',
+        });
+    }
+    return {
+        help: Boolean(values.help),
+        project: positionals[0],
+        sync: Boolean(values.sync),
+        variant: variant,
+    };
+}

package/build/cli.d.ts

@@ -0,0 +1,3 @@
+declare function runAsync(argv?: string[], io?: Pick<Console, 'error' | 'log' | 'warn'>): Promise<number>;
+declare function main(argv?: string[]): Promise<void>;
+export { main, runAsync };

package/build/cli.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+exports.runAsync = runAsync;
+const node_path_1 = __importDefault(require("node:path"));
+const options_1 = require("./buildHap/options");
+const options_2 = require("./doctor/options");
+const errors_1 = require("./errors");
+const options_3 = require("./exportEmbed/options");
+const options_4 = require("./modules/options");
+const options_5 = require("./prebuild/options");
+const project_1 = require("./project");
+const projectLock_1 = require("./projectLock");
+const options_6 = require("./run/options");
+const options_7 = require("./start/options");
+const Help = `Usage: expo-harmony <command> [project] [options]
+
+Commands:
+  start                 Start Expo Metro for Harmony development
+  prebuild              Generate the Harmony native project with Expo CNG
+  prebuild --clean      Safely recreate the managed Harmony directory
+  prebuild --check      Compare generated desired state without project writes
+  build                 Build a HAP without selecting or contacting a device
+  doctor                Validate config, versions, Metro, RNOH, SDK, and signing
+  modules list          List native module candidates and their discovery source
+  modules inspect       Resolve Harmony metadata (--package narrows the result)
+  modules verify        Validate module config, registration conflicts and safe paths
+  export:embed          Export validated Hermes bytecode, assets, and a source map
+  run                   Build, install, and launch the Harmony app
+
+Options:
+  --no-install          Skip dependency install (prebuild) or HAP install (run)
+  --npm|--yarn|--pnpm|--bun
+                        Select the package manager used by prebuild dependency install
+  --skip-dependency-update <packages>
+                        Preserve comma-separated dependency versions
+  --device <id-or-name> Select an HDC target or start a local emulator by name
+  --variant <mode>      Build debug or release (default: debug)
+  --no-bundler          Use an already-running Expo Metro server
+  --app-id <bundleName>
+                        Launch another installed app (requires --no-install when different)
+  --port <number>       Metro and device reverse port (default: 8081)
+  --sync                Re-run prebuild before building
+  --check               Validate an existing export without writing
+  --reset-cache         Reset Metro while exporting or starting
+  -c, --clear           Alias for --reset-cache (start)
+  -h, --help            Show this help
+`;
+function parseInvocation(argv) {
+    if (argv.length === 0 || (argv.length === 1 && ['--help', '-h'].includes(argv[0]))) {
+        return { command: 'help' };
+    }
+    const command = argv[0];
+    if (!['build', 'prebuild', 'doctor', 'export:embed', 'modules', 'run', 'start'].includes(command)) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', `Unknown command: ${command}`, {
+            operation: 'parse-arguments',
+        });
+    }
+    const parsed = command === 'build'
+        ? (0, options_1.parseBuildArgs)(argv.slice(1))
+        : command === 'prebuild'
+            ? (0, options_5.parsePrebuildArgs)(argv.slice(1), { allowProject: true })
+            : command === 'doctor'
+                ? (0, options_2.parseDoctorArgs)(argv.slice(1))
+                : command === 'export:embed'
+                    ? (0, options_3.parseExportEmbedArgs)(argv.slice(1))
+                    : command === 'modules'
+                        ? (0, options_4.parseModulesArgs)(argv.slice(1))
+                        : command === 'start'
+                            ? (0, options_7.parseStartArgs)(argv.slice(1))
+                            : (0, options_6.parseRunArgs)(argv.slice(1));
+    if (parsed.help)
+        return { command: 'help' };
+    const projectRoot = (0, project_1.resolveProject)(parsed.project ? node_path_1.default.resolve(parsed.project) : process.cwd());
+    return { command, parsed, projectRoot };
+}
+async function runAsync(argv = process.argv.slice(2), io = console) {
+    const invocation = parseInvocation(argv);
+    if (invocation.command === 'help') {
+        io.log(Help);
+        return 0;
+    }
+    if (invocation.command === 'start') {
+        const { startExpoMetroAsync } = await import('./run/metro.js');
+        const metro = await startExpoMetroAsync(invocation.projectRoot, {
+            ...invocation.parsed,
+            interactive: true,
+        });
+        try {
+            if (metro.owner === 'existing') {
+                io.log(`Expo Metro is already running on port ${metro.port}.`);
+                if (invocation.parsed.resetCache) {
+                    io.warn('Stop the existing Metro server and run this command again to reset its cache.');
+                }
+            }
+            else {
+                io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+                await metro.waitAsync();
+            }
+            return 0;
+        }
+        finally {
+            await metro.stop();
+        }
+    }
+    if (invocation.command === 'doctor') {
+        const { doctorAsync, formatDoctor } = await import('./doctor/doctor.js');
+        const result = await doctorAsync(invocation.projectRoot, { requireBuildTools: true });
+        io.log(formatDoctor(result));
+        return result.ok ? 0 : 1;
+    }
+    if (invocation.command === 'build') {
+        const { buildHarmonyAsync } = await import('./buildHap/build.js');
+        const result = await buildHarmonyAsync(invocation.projectRoot, {
+            ...invocation.parsed,
+            io,
+        });
+        io.log(`Built ${result.variant} HAP at ${result.hapPath}; no device actions were performed.`);
+        return 0;
+    }
+    if (invocation.command === 'export:embed') {
+        const { exportEmbedAsync } = await import('./exportEmbed/export.js');
+        const result = await exportEmbedAsync(invocation.projectRoot, invocation.parsed);
+        if (invocation.parsed.check)
+            io.log('Harmony export bundle, assets, and source map are valid.');
+        else
+            io.log(`Exported Hermes bytecode ${result.bundle.path} with ${result.assets.length} asset file(s).`);
+        return 0;
+    }
+    if (invocation.command === 'modules') {
+        const { formatModulesResult, runModulesCommandAsync } = await import('./modules/modules.js');
+        const result = await runModulesCommandAsync(invocation.projectRoot, invocation.parsed);
+        io.log(formatModulesResult(result));
+        return result.ok ? 0 : 1;
+    }
+    if (invocation.command === 'run') {
+        const { runHarmonySessionAsync } = await import('./run/run.js');
+        const session = await runHarmonySessionAsync(invocation.projectRoot, {
+            ...invocation.parsed,
+            interactiveBundler: true,
+            io,
+        });
+        const { result } = session;
+        io.log(`Launched ${result.bundleName} on ${result.device.id} (${result.variant}).`);
+        if (session.metro.owner === 'started') {
+            io.log('\n› Logs for your project will appear below. Press Ctrl+C to exit.');
+            await session.metro.waitAsync();
+        }
+        return 0;
+    }
+    const { check, clean, passthrough } = invocation.parsed;
+    if (check && passthrough.length) {
+        throw new errors_1.HarmonyCliError('ERR_HARMONY_CONFIG_INVALID', '--check cannot be combined with mutating prebuild options.');
+    }
+    return (0, projectLock_1.withHarmonyProjectLockAsync)(invocation.projectRoot, check ? 'prebuild-check' : 'prebuild', async () => {
+        if (clean) {
+            const { assertSafeCleanTarget } = await import('./prebuild/clean.js');
+            await assertSafeCleanTarget(invocation.projectRoot);
+        }
+        const { doctorAsync, formatDoctor } = await import('./doctor/doctor.js');
+        const doctor = await doctorAsync(invocation.projectRoot, {
+            requireBuildTools: false,
+            validateGeneratedProject: !clean,
+            validateModules: false,
+        });
+        if (!doctor.ok) {
+            io.error(formatDoctor(doctor));
+            throw new errors_1.HarmonyCliError('ERR_HARMONY_DOCTOR_FAILED', 'Harmony doctor found blocking errors.', {
+                operation: 'doctor',
+            });
+        }
+        for (const item of doctor.checks.filter(item => item.status === 'warn'))
+            io.warn(`! ${item.message}`);
+        if (check) {
+            const { checkAsync } = await import('./prebuild/check.js');
+            const result = await checkAsync(invocation.projectRoot);
+            if (result.clean)
+                io.log('Harmony CNG output is up to date.');
+            else
+                for (const change of result.changes)
+                    io.log(`${change.type}: ${change.path}`);
+            return result.clean ? 0 : 2;
+        }
+        const { prebuildParsedAsync } = await import('./prebuild/prebuild.js');
+        await prebuildParsedAsync(invocation.projectRoot, passthrough);
+        return 0;
+    });
+}
+async function main(argv = process.argv.slice(2)) {
+    try {
+        const code = await runAsync(argv);
+        process.exitCode = code;
+    }
+    catch (error) {
+        const code = error.code || 'ERR_HARMONY_UNKNOWN';
+        console.error(`[${code}] ${error.message}`);
+        process.exitCode = error.exitCode || 1;
+    }
+}

package/build/doctor/doctor.d.ts

@@ -0,0 +1,20 @@
+export interface DoctorCheck {
+    details?: unknown;
+    id: string;
+    message: string;
+    status: 'error' | 'pass' | 'warn';
+}
+export interface DoctorResult {
+    checks: DoctorCheck[];
+    ok: boolean;
+    projectRoot: string;
+}
+interface DoctorOptions {
+    requireBuildTools?: boolean;
+    requireDeviceTools?: boolean;
+    validateGeneratedProject?: boolean;
+    validateModules?: boolean;
+}
+declare function doctorAsync(projectRoot: string, options?: DoctorOptions): Promise<DoctorResult>;
+declare function formatDoctor(result: DoctorResult): string;
+export { doctorAsync, formatDoctor };