rea-agents 4.1.0 → 6.0.0

package/dist/application/ProcessHarness.js

@@ -1,275 +0,0 @@
-import { parseProcessCapture } from "../domain/processCapture.js";
-import { err, ok } from "../domain/result.js";
-import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
-import { ProcessCaptureError, processCaptureCancelled, } from "./ProcessCaptureError.js";
-export { ProcessCaptureError } from "./ProcessCaptureError.js";
-import { startProcessSampler } from "./ProcessSampling.js";
-import { snapshotRoots } from "./FilesystemSnapshot.js";
-import { TerminalRenderer } from "./TerminalRenderer.js";
-import { normalizeProcessText } from "./ProcessNormalization.js";
-import { selectCapturedProcessGroupIds } from "../process/ProcessOwnershipProcessTree.js";
-import { awaitTerminalExit, buildCaptureResult, captureTerminalFrames, createRunManifest, observeSettlement, prepareProcessCapture, releaseProcessResources, resolveProcessResult, settleProcessCaptureJournal, } from "./ProcessCaptureLifecycle.js";
-import { assertNotCancelled, resolveProcessScenarioRuntimePaths, } from "./ProcessScenarioRuntimeValidation.js";
-import { createProcessCaptureJournal, scheduleScenarioInteractions, } from "./ProcessCaptureJournal.js";
-import { makeProcessCaptureEnvironment } from "./ProcessCaptureEnvironment.js";
-import { classifyFilesystemEffects } from "./ProcessFilesystemEffects.js";
-import { processCaptureOwnershipUnavailableReason } from "./ProcessCaptureCapability.js";
-export { probeProcessCaptureCapability } from "./ProcessCaptureCapability.js";
-const cleanupFailedStartup = async (options) => {
-    options.terminal?.kill("SIGKILL");
-    const cleanupFailure = await releaseProcessResources({
-        ...options,
-        capturedProcessGroupIds: options.terminal === undefined ? [] : [options.terminal.pid],
-    });
-    if (cleanupFailure !== undefined)
-        throw new ProcessCaptureError(cleanupFailure, {
-            cause: options.cause,
-            reason: "cleanup_incomplete",
-        });
-    throw options.cause;
-};
-const createTerminalRenderer = (scenario, temporaryRoot, terminalPid, recordEvent) => new TerminalRenderer({
-    columns: scenario.terminal.columns,
-    rows: scenario.terminal.rows,
-    scrollback: scenario.terminal.scrollback,
-    maxBytes: scenario.limits.output_bytes,
-    normalize: (value) => normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),
-    recordEvent,
-});
-const startCaptureRuntime = async (options) => {
-    const { scenario } = options;
-    let renderer;
-    let terminal;
-    try {
-        const { spawn } = await import("@lydell/node-pty");
-        const startedAt = new Date();
-        const started = Date.now();
-        let lastOutput = started;
-        renderer = createTerminalRenderer(scenario, options.temporaryRoot, () => terminal?.pid ?? -1, options.recordEvent);
-        terminal = spawn(scenario.executable, [...scenario.arguments], {
-            cwd: scenario.working_directory,
-            env: makeProcessCaptureEnvironment(options),
-            cols: scenario.terminal.columns,
-            rows: scenario.terminal.rows,
-            name: "xterm-256color",
-        });
-        const framesTruncated = captureTerminalFrames({
-            ...options,
-            terminal,
-            started,
-            onOutput: () => (lastOutput = Date.now()),
-            renderer,
-        });
-        scheduleScenarioInteractions({
-            ...options,
-            getTerminal: () => terminal,
-            renderer,
-            started,
-        });
-        const stopSampler = startProcessSampler({
-            rootPid: terminal.pid,
-            runId: options.runId,
-            started,
-            limit: scenario.limits.processes,
-            samples: options.samples,
-            recordEvent: options.recordEvent,
-        });
-        return {
-            renderer,
-            terminal,
-            started,
-            startedAt,
-            lastOutput: () => lastOutput,
-            framesTruncated,
-            stopSampler,
-        };
-    }
-    catch (cause) {
-        return cleanupFailedStartup({
-            cause,
-            timers: options.timers,
-            terminal,
-            renderer,
-            runId: options.runId,
-            temporaryRoot: options.temporaryRoot,
-        });
-    }
-};
-const finishProcessRun = async (options) => {
-    await options.stopSampler();
-    const cleanupFailure = await releaseProcessResources({
-        timers: options.timers,
-        terminal: options.runtime?.terminal,
-        renderer: options.runtime?.renderer,
-        runId: options.runId,
-        temporaryRoot: options.temporaryRoot,
-        capturedProcessGroupIds: options.runtime === undefined
-            ? []
-            : selectCapturedProcessGroupIds(options.runtime.terminal.pid, options.samples),
-    });
-    let { capture, executionFailure } = options;
-    let verifiedCapture;
-    if (capture !== undefined && cleanupFailure === undefined) {
-        const settlement = capture.settlement.state === "quiesced"
-            ? { ...capture.settlement, cleanup_outcome: "not_required" }
-            : { ...capture.settlement, cleanup_outcome: "cleaned" };
-        const completedCapture = {
-            ...capture,
-            settlement,
-            cleanup: {
-                owned_process_group: "verified",
-                temporary_root: "removed",
-            },
-        };
-        try {
-            verifiedCapture = parseProcessCapture(completedCapture);
-        }
-        catch (cause) {
-            executionFailure = new ProcessCaptureError(`process capture validation failed${cause instanceof Error ? `: ${cause.message}` : ""}`, { cause });
-        }
-    }
-    return resolveProcessResult(verifiedCapture, executionFailure, cleanupFailure);
-};
-const completeCapture = async (options) => {
-    const { runtime, scenario } = options;
-    const { reason } = options.exit;
-    if (reason === "cancelled")
-        throw processCaptureCancelled();
-    const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent, options.hostPlatform);
-    const samplingPartial = (await runtime.stopSampler()).partial;
-    await settleProcessCaptureJournal(options.eventJournal);
-    assertNotCancelled(options.signal);
-    const after = await snapshotRoots(scenario, options.signal);
-    options.recordEvent("filesystem_checkpoints", 1);
-    const renderedFrames = await runtime.renderer.frames();
-    const checkpoints = [
-        {
-            name: "before",
-            at_ms: 0,
-            files: options.before.files,
-            effects: [],
-            truncated: options.before.truncated,
-        },
-        {
-            name: "after_settlement",
-            at_ms: Math.max(0, Date.now() - runtime.started),
-            files: after.files,
-            effects: classifyFilesystemEffects(options.before.files, after.files),
-            truncated: after.truncated,
-        },
-    ];
-    const manifest = await createRunManifest(scenario, runtime.startedAt, new Date(), { platform: options.hostPlatform, architecture: process.arch });
-    const truncated = options.initiallyTruncated ||
-        after.truncated ||
-        runtime.framesTruncated() ||
-        checkpoints.some(({ truncated: partial }) => partial) ||
-        samplingPartial ||
-        runtime.renderer.truncated();
-    return buildCaptureResult({
-        frames: options.frames,
-        exit: { ...options.exit, reason },
-        samples: options.samples,
-        before: options.before,
-        after,
-        truncated,
-        scenario,
-        rootPid: runtime.terminal.pid,
-        samplingPartial,
-        renderedFrames,
-        interactions: options.interactions,
-        checkpoints,
-        settlement,
-        manifest,
-        eventJournal: options.eventJournal,
-    });
-};
-/** Execute one caller-selected scenario and return bounded observations. */
-const runProcessScenario = async (scenario, signal, hostEnvironment = process.env, hostPlatform = process.platform) => {
-    const { temporaryRoot, runId, before } = await prepareProcessCapture(scenario, signal);
-    const frames = [];
-    const samples = [];
-    const journal = createProcessCaptureJournal();
-    const { entries: eventJournal, recordEvent } = journal;
-    recordEvent("filesystem_checkpoints", 0);
-    let runtime;
-    const timers = new Set();
-    let capture;
-    let executionFailure;
-    let stopSampler = async () => ({ partial: false });
-    const interactions = [];
-    const dispatchedEventIndexes = new Set();
-    try {
-        runtime = await startCaptureRuntime({
-            scenario,
-            hostEnvironment,
-            temporaryRoot,
-            runId,
-            frames,
-            samples,
-            interactions,
-            timers,
-            dispatchedEventIndexes,
-            recordEvent,
-            ...(signal === undefined ? {} : { signal }),
-        });
-        stopSampler = runtime.stopSampler;
-        const exit = await awaitTerminalExit({
-            terminal: runtime.terminal,
-            scenario,
-            started: runtime.started,
-            lastOutput: runtime.lastOutput,
-            signal,
-            timers,
-            interactions,
-            dispatchedEventIndexes,
-            recordEvent,
-        });
-        capture = await completeCapture({
-            scenario,
-            hostPlatform,
-            runtime,
-            runId,
-            temporaryRoot,
-            before,
-            frames,
-            samples,
-            interactions,
-            exit,
-            initiallyTruncated: before.truncated,
-            eventJournal,
-            recordEvent,
-            ...(signal === undefined ? {} : { signal }),
-        });
-    }
-    catch (cause) {
-        runtime?.terminal.kill("SIGKILL");
-        executionFailure = cause;
-    }
-    return finishProcessRun({
-        runtime,
-        timers,
-        runId,
-        temporaryRoot,
-        samples,
-        stopSampler,
-        capture,
-        executionFailure,
-    });
-};
-/** Execute one scenario through a typed expected-failure channel. */
-export const captureProcessScenario = async (scenario, signal, platform = process.platform, environment = process.env) => {
-    const ownershipReason = processCaptureOwnershipUnavailableReason(platform);
-    if (ownershipReason !== undefined)
-        return err(new AnalysisCapabilityUnavailableError("rea-process", "capture_process_scenario", ownershipReason));
-    try {
-        assertNotCancelled(signal);
-        const resolvedScenario = await resolveProcessScenarioRuntimePaths(scenario, environment);
-        return ok(await runProcessScenario(resolvedScenario, signal, environment, platform));
-    }
-    catch (cause) {
-        return err(cause instanceof ProcessCaptureError
-            ? cause
-            : new ProcessCaptureError("process capture failed", { cause }));
-    }
-};

package/dist/application/StoreFileLock.js

@@ -1,124 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { lstat, mkdtemp, open, readdir, rename, rm, rmdir, unlink, } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { readBoundedFileBytes } from "../process/BoundedFileBytes.js";
-class StoreFileLockOccupied extends Error {
-    code = "EEXIST";
-    constructor(cause) {
-        super("Store transaction lock is occupied", { cause });
-    }
-}
-/** Atomically publish a populated directory so another owner cannot replace a live lock. */
-export const createStoreFileLock = async (path) => {
-    if (await exists(path))
-        throw new StoreFileLockOccupied();
-    const staged = await mkdtemp(join(dirname(path), ".rea-store-lock-"));
-    const owner = `owner-${randomUUID()}`;
-    try {
-        const handle = await open(join(staged, owner), "wx", 0o600);
-        try {
-            await handle.writeFile(`${String(process.pid)}\n`, "utf8");
-            await handle.sync();
-        }
-        finally {
-            await handle.close();
-        }
-        try {
-            // Rename cannot replace a nonempty directory: the owner entry is present before publication.
-            await rename(staged, path);
-        }
-        catch (cause) {
-            if (await exists(path))
-                throw new StoreFileLockOccupied(cause);
-            throw cause;
-        }
-        return {
-            release: async () => {
-                await removeOwner(path, owner).catch((cause) => {
-                    // best-effort cleanup: lock release must not reject unhandled.
-                    void cause;
-                });
-            },
-        };
-    }
-    finally {
-        await rm(staged, { recursive: true, force: true });
-    }
-};
-/** Recover a dead owner's directory lock or a legacy PID file; leave live and unknown owners intact. */
-export const removeStaleStoreFileLock = async (path) => {
-    try {
-        const stats = await lstat(path);
-        if (stats.isFile()) {
-            if (!(await ownerIsDead(path)))
-                return false;
-            await unlink(path);
-            return true;
-        }
-        if (!stats.isDirectory())
-            return false;
-        const entries = await readdir(path);
-        if (entries.length === 0) {
-            await rmdir(path);
-            return true;
-        }
-        const owner = entries[0];
-        if (entries.length !== 1 ||
-            owner === undefined ||
-            !/^owner-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/u.test(owner) ||
-            !(await ownerIsDead(join(path, owner))))
-            return false;
-        await removeOwner(path, owner);
-        return true;
-    }
-    catch (cause) {
-        // best-effort cleanup: stale lock probing; failure means the lock stands.
-        void cause;
-        return false;
-    }
-};
-const removeOwner = async (path, owner) => {
-    // A successor has a different entry, so stale cleanup cannot make its directory empty.
-    await unlink(join(path, owner));
-    await rmdir(path);
-};
-const ownerIsDead = async (path) => {
-    const stats = await lstat(path);
-    if (!stats.isFile() || stats.size > 32)
-        return false;
-    const handle = await open(path, "r");
-    let bytes;
-    try {
-        bytes = await readBoundedFileBytes(handle, 32);
-    }
-    finally {
-        await handle.close();
-    }
-    const encoded = bytes?.toString("utf8").trim();
-    return (encoded !== undefined &&
-        /^[1-9][0-9]{0,9}$/u.test(encoded) &&
-        !processIsAlive(Number(encoded)));
-};
-const exists = async (path) => {
-    try {
-        await lstat(path);
-        return true;
-    }
-    catch (cause) {
-        if (errorCode(cause) === "ENOENT")
-            return false;
-        throw cause;
-    }
-};
-const processIsAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (cause) {
-        return errorCode(cause) !== "ESRCH";
-    }
-};
-const errorCode = (cause) => typeof cause === "object" && cause !== null && "code" in cause
-    ? cause.code
-    : undefined;

package/dist/application/runtime.js

@@ -1,53 +0,0 @@
-import { HopperProvider } from "../hopper/HopperProvider.js";
-import { GhidraProvider } from "../ghidra/GhidraProvider.js";
-import { IdaProvider } from "../ida/IdaProvider.js";
-import { silentLogger } from "../logger.js";
-import { GENERATED_AUXILIARY_PROVIDERS } from "../generatedMcpToolCatalog.js";
-import { AnalysisProviderRegistry } from "./AnalysisProviderRegistry.js";
-import { composeBinarySession } from "./BinarySessionComposition.js";
-import { nativeHostCapabilities } from "../native/NativeHostCapabilities.js";
-import { LazyAnalysisProvider } from "./LazyAnalysisProvider.js";
-import { ManagedStaticProvider } from "../dotnet/ManagedStaticProvider.js";
-import { SessionProviderRouter } from "./SessionProviderRouter.js";
-/**
- * Compose the target-switching runtime shared directly by CLI and MCP adapters.
- * This is the sole production wiring point, so both adapters share identical
- * provider selection, profile, lifecycle, and Evidence semantics.
- */
-export const createBinarySession = (config, logger = silentLogger) => {
-    const hopper = new HopperProvider(config, logger);
-    const ghidra = new GhidraProvider(config, logger);
-    const ida = new IdaProvider(config);
-    const auxiliary = new Map(GENERATED_AUXILIARY_PROVIDERS.map((provider) => [
-        provider.identity.id,
-        provider,
-    ]));
-    const lazyProvider = (id, load) => {
-        const generated = auxiliary.get(id);
-        if (generated === undefined)
-            throw new TypeError(`Missing generated provider metadata for ${id}`);
-        return new LazyAnalysisProvider({
-            ...generated,
-            capabilities: nativeHostCapabilities(generated.capabilities),
-            load,
-        });
-    };
-    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida], config.analysisProvider), [
-        lazyProvider("rea-artifact-graph", async () => {
-            const { ArtifactProvider } = await import("../artifacts/ArtifactProvider.js");
-            return new ArtifactProvider();
-        }),
-        lazyProvider("native-macos", async () => {
-            const { NativeMacOSProvider } = await import("../native/NativeMacOSProvider.js");
-            return new NativeMacOSProvider();
-        }),
-        lazyProvider("rea-dotnet-static", async () => {
-            const { ManagedStaticProvider } = await import("../dotnet/ManagedStaticProvider.js");
-            return new ManagedStaticProvider();
-        }),
-    ]);
-};
-/** Compose an execution-free managed session without native provider selection. */
-export const createManagedBinarySession = () => composeBinarySession(SessionProviderRouter.selectable(new AnalysisProviderRegistry([]), [
-    new ManagedStaticProvider(),
-]));

package/dist/contracts/processCaptureExample.js

@@ -1,2 +0,0 @@
-/** Minimal valid process capture retained as a public contract example. */
-export { EMPTY_PROCESS_CAPTURE_EXAMPLE } from "../domain/processCaptureExample.js";

package/dist/domain/appleApplication.js

@@ -1,181 +0,0 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { z } from "zod";
-import { parseArtifactInventoryEvidence } from "./artifactInventoryEvidence.js";
-import { evidenceSchema } from "./evidence.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
-const evidenceIdSchema = prefixedDigestSchema("ev");
-const pathSchema = z.string().min(1);
-const componentSchema = z.strictObject({
-    path: pathSchema,
-    artifact_id: prefixedDigestSchema("art"),
-    sha256: digestSchema,
-    format: z.string().min(1),
-});
-/** Authenticated artifact inventory pages projected as one Apple application. */
-export const appleApplicationProjectionInputSchema = z.strictObject({
-    inventory_evidence: z.array(evidenceSchema).min(1),
-});
-/** Deterministic, execution-free Apple application inventory projection. */
-export const appleApplicationProjectionResultSchema = z.strictObject({
-    projection_id: prefixedDigestSchema("aap"),
-    root_sha256: digestSchema,
-    root_format: z.literal("ipa"),
-    source_evidence_ids: z.array(evidenceIdSchema).min(1),
-    application_roots: z.array(pathSchema),
-    components: z.strictObject({
-        bundle_metadata: z.array(componentSchema),
-        executables: z.array(componentSchema),
-        frameworks: z.array(componentSchema),
-        native_libraries: z.array(componentSchema),
-        javascript: z.array(componentSchema),
-        signing: z.array(componentSchema),
-    }),
-    runtime_families: z.array(z.enum([
-        "native",
-        "swift-objective-c",
-        "javascript",
-        "react-native",
-        "flutter",
-        "unity",
-    ])),
-    bridge_candidates: z.array(z.strictObject({
-        source_path: pathSchema,
-        native_path: pathSchema,
-        basis: z.enum([
-            "javascript-and-native-content",
-            "react-native-convention",
-            "flutter-convention",
-            "unity-convention",
-        ]),
-    })),
-    coverage: z.strictObject({
-        status: z.enum(["complete-within-inventory", "partial"]),
-        inventory_complete: z.boolean(),
-    }),
-    limitations: z.array(z.string().min(1)),
-});
-/** Project exact IPA paths and hashes without parsing or executing target code. */
-export const projectAppleApplication = (input) => {
-    const parsed = appleApplicationProjectionInputSchema.parse(input);
-    const { evidence, inventory } = parseArtifactInventoryEvidence(parsed.inventory_evidence);
-    if (inventory.manifest.root_format !== "ipa")
-        throw new TypeError("Apple application projection requires IPA Evidence");
-    const nodes = new Map(inventory.nodes.map((node) => [node.artifact_id, node]));
-    const all = inventory.occurrences
-        .filter((occurrence) => occurrence.artifact_id !== null && occurrence.logical_path !== ".")
-        .map((occurrence) => {
-        const node = nodes.get(occurrence.artifact_id ?? "");
-        if (node === undefined)
-            throw new TypeError("Apple application occurrence has no artifact node");
-        return {
-            path: occurrence.logical_path,
-            artifact_id: node.artifact_id,
-            sha256: node.sha256,
-            format: node.format,
-        };
-    });
-    const roots = [
-        ...new Set(inventory.occurrences.flatMap(({ logical_path: path }) => {
-            const match = /^(Payload\/[^/]+\.app)(?:\/|$)/u.exec(path);
-            return match?.[1] === undefined ? [] : [match[1]];
-        })),
-    ].sort(compare);
-    const classified = classifyComponents(all, roots);
-    const runtimeFamilies = identifyRuntimeFamilies(all);
-    const bridgeProjection = identifyBridgeCandidates(classified.javascript, deduplicateComponents([
-        ...classified.executables,
-        ...classified.native_libraries,
-    ]));
-    const limitations = projectionLimitations(inventory.complete, roots);
-    const withoutId = {
-        root_sha256: inventory.manifest.root_sha256,
-        root_format: "ipa",
-        source_evidence_ids: evidence
-            .map(({ evidence_id: id }) => id)
-            .sort(compare),
-        application_roots: roots,
-        components: classified,
-        runtime_families: runtimeFamilies,
-        bridge_candidates: bridgeProjection.candidates,
-        coverage: {
-            status: inventory.complete
-                ? "complete-within-inventory"
-                : "partial",
-            inventory_complete: inventory.complete,
-        },
-        limitations,
-    };
-    return appleApplicationProjectionResultSchema.parse({
-        ...withoutId,
-        projection_id: `aap_${digest(withoutId)}`,
-    });
-};
-const classifyComponents = (all, roots) => {
-    const withinApp = (path) => roots.some((root) => path.startsWith(`${root}/`));
-    return {
-        bundle_metadata: all.filter(({ path }) => /(?:^|\/)Info\.plist$/u.test(path)),
-        executables: all.filter(({ path, format }) => withinApp(path) && ["mach-o", "mach-o-universal"].includes(format)),
-        frameworks: all.filter(({ path }) => /\.framework\//u.test(path)),
-        native_libraries: all.filter(({ path }) => /\.(?:dylib|so)$/iu.test(path)),
-        javascript: all.filter(({ format }) => format === "javascript-bundle"),
-        signing: all.filter(({ path }) => /(?:^|\/)(?:embedded\.mobileprovision|_CodeSignature\/CodeResources)$/u.test(path)),
-    };
-};
-const deduplicateComponents = (values) => [...new Map(values.map((value) => [value.path, value])).values()].sort((left, right) => compare(left.path, right.path));
-const identifyRuntimeFamilies = (all) => {
-    const paths = all.map(({ path }) => path.toLowerCase());
-    const families = new Set();
-    if (all.some(({ format }) => ["mach-o", "mach-o-universal"].includes(format)))
-        families.add("native");
-    if (paths.some((path) => /\.(?:dylib|framework\/[^/]+)$/u.test(path)))
-        families.add("swift-objective-c");
-    if (all.some(({ format }) => format === "javascript-bundle"))
-        families.add("javascript");
-    if (paths.some((path) => path.includes("reactnative") ||
-        path.includes("react.framework") ||
-        path.includes("hermes")))
-        families.add("react-native");
-    if (paths.some((path) => path.includes("flutter.framework") || path.includes("app.framework")))
-        families.add("flutter");
-    if (paths.some((path) => path.includes("unityframework.framework")))
-        families.add("unity");
-    return [...families].sort(compare);
-};
-const identifyBridgeCandidates = (scripts, native) => ({
-    candidates: scripts.flatMap((script) => native.map((item) => ({
-        source_path: script.path,
-        native_path: item.path,
-        basis: bridgeBasis(item.path),
-    }))),
-});
-const bridgeBasis = (path) => {
-    const lower = path.toLowerCase();
-    if (lower.includes("react"))
-        return "react-native-convention";
-    if (lower.includes("flutter") || lower.includes("app.framework"))
-        return "flutter-convention";
-    if (lower.includes("unity"))
-        return "unity-convention";
-    return "javascript-and-native-content";
-};
-const projectionLimitations = (complete, roots) => [
-    ...(!complete
-        ? ["Source inventory pages are incomplete; absence is unknown."]
-        : []),
-    ...(roots.length === 0
-        ? [
-            "No Payload/*.app directory was present in the supplied inventory pages.",
-        ]
-        : []),
-    "Bundle identifiers and signing claims require dedicated plist and CMS parsing; this projection reports only exact paths and hashes.",
-    "Bridge candidates are path-based hypotheses, not observed runtime calls.",
-];
-const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
-const digest = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Apple application projection is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};