reverseport 0.0.0-stage → 1.2.0

package/dist/native/NativeMacOSProviderMetadata.js

@@ -0,0 +1,46 @@
+import { NATIVE_TOOL_CONTRACTS } from "../contracts/native/nativeToolContracts.js";
+/** Public identity committed by macOS-native inspection observations. */
+export const NATIVE_MACOS_PROVIDER_IDENTITY = Object.freeze({
+    id: "native-macos",
+    name: "macOS native inspection utilities",
+    version: null,
+});
+/** Operations whose target process can show UI, use the network and write files. */
+const OWNED_PROCESS_OPERATIONS = new Set([
+    "capture_native_ui_scenario",
+    "observe_native_calls",
+]);
+/** Declare native host coverage without creating a command runner. */
+export const nativeMacOSCapabilities = (platform = process.platform) => {
+    const available = platform === "darwin";
+    return Object.freeze([
+        ...NATIVE_TOOL_CONTRACTS,
+        { name: "inspect_native_dispatch_metadata" },
+    ].map((contract) => {
+        const availability = available
+            ? { available: true, reason: null }
+            : {
+                available: false,
+                availabilityCode: "unsupported_host",
+                reason: "Native macOS utilities require macOS.",
+            };
+        return Object.freeze({
+            provider: NATIVE_MACOS_PROVIDER_IDENTITY,
+            operation: contract.name,
+            ...availability,
+            effects: Object.freeze({
+                mutatesArtifact: false,
+                launchesProcess: contract.name !== "inspect_native_dispatch_metadata",
+                mayShowUi: OWNED_PROCESS_OPERATIONS.has(contract.name),
+                mayAccessNetwork: OWNED_PROCESS_OPERATIONS.has(contract.name),
+                mayWriteFilesystem: OWNED_PROCESS_OPERATIONS.has(contract.name) ||
+                    contract.name === "observe_native_ui",
+                changesPermissions: false,
+                requiresRoot: false,
+            }),
+            limitations: Object.freeze([
+                "Availability and textual formats depend on the installed macOS/Xcode toolchain.",
+            ]),
+        });
+    }));
+};

package/dist/native/NativeMachoInspection.js

@@ -0,0 +1,273 @@
+import { AnalysisOutputError } from "../domain/analysisErrorCore.js";
+import { inspectMachoSchema, } from "../domain/native/nativeInspection.js";
+import { jsonValueSchema } from "../domain/jsonValue.js";
+import { err, ok } from "../domain/result.js";
+import { parseDyldSymbols } from "./parsers/dyldInfo.js";
+import { parseLipoArchitectures } from "./parsers/lipo.js";
+import { withoutEchoedPathHeader } from "./parsers/echoedPath.js";
+import { parseOtoolLoadCommands } from "./parsers/otool.js";
+import { reconcileMachoUuid } from "./parsers/machoUuid.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
+const DISCOVERY_COMMANDS = [
+    ["file", ["-b"]],
+    ["lipo", ["-detailed_info"]],
+];
+const REQUIRED_SLICE_COMMANDS = [
+    ["otool", ["-h", "-l"]],
+    ["nm", ["-gjU"]],
+    ["dyld_info", ["-imports"]],
+    ["dyld_info", ["-exports"]],
+    ["dwarfdump", ["--uuid"]],
+];
+const OPTIONAL_VTOOL_COMMAND = ["vtool", ["-show-build"]];
+const VTOOL_UNAVAILABLE_LIMITATION = "vtool is unavailable; build metadata is normalized from otool only.";
+/** Inspect one Mach-O with the required native commands and normalized output. */
+export const inspectNativeMacho = async (context) => {
+    const captures = [];
+    for (const [tool, prefix] of DISCOVERY_COMMANDS) {
+        const captured = await context.run(tool, [...prefix, context.target.path], context.signal);
+        if (!captured.ok)
+            return err(captured.error);
+        captures.push(captured.value);
+    }
+    const lipo = captures.find(({ tool }) => tool === "lipo");
+    if (lipo === undefined)
+        throw new TypeError("Missing lipo capture");
+    const architectures = parseLipoArchitectures(lipo.stdout);
+    const availableArchitectures = architectures.map(({ name }) => name);
+    const selection = selectArchitecture(context.target, availableArchitectures);
+    if (selection.status === "absent")
+        return err(new AnalysisOutputError("inspect_macho", `lipo did not list ${selection.architecture}; refusing to read another slice`));
+    const selectedArchitecture = selection.status === "selected" ? selection.architecture : null;
+    for (const [tool, prefix] of REQUIRED_SLICE_COMMANDS) {
+        const captured = await context.run(tool, [
+            ...prefix,
+            ...selectedArchitectureArguments(tool, selectedArchitecture),
+            context.target.path,
+        ], context.signal);
+        if (!captured.ok)
+            return err(captured.error);
+        captures.push(captured.value);
+    }
+    const limitations = [];
+    const [tool, prefix] = OPTIONAL_VTOOL_COMMAND;
+    const optional = await context.run(tool, [
+        ...prefix,
+        ...selectedArchitectureArguments(tool, selectedArchitecture),
+        context.target.path,
+    ], context.signal);
+    if (optional.ok)
+        captures.push(optional.value);
+    else if (optional.error._tag === "AnalysisCapabilityUnavailableError")
+        limitations.push(VTOOL_UNAVAILABLE_LIMITATION);
+    else
+        return err(optional.error);
+    const otool = captures.find(({ tool }) => tool === "otool");
+    if (otool === undefined)
+        throw new TypeError("Missing otool capture");
+    let load;
+    try {
+        load = parseOtoolLoadCommands(sliceOutput(otool));
+    }
+    catch (cause) {
+        return err(new AnalysisOutputError("inspect_macho", "Malformed otool load-command output", {
+            cause,
+            capturedOutput: {
+                stdout: otool.stdout,
+                stderr: otool.stderr,
+                truncated: false,
+                stdout_bytes: otool.stdoutBytes,
+                stderr_bytes: otool.stderrBytes,
+                exit_code: otool.exitCode,
+                signal: otool.signal,
+            },
+        }));
+    }
+    const selectedArchitectureName = selectedArchitecture ??
+        (architectures.length === 1 ? (architectures[0]?.name ?? null) : null);
+    const containerOffset = selectedArchitectureName === null
+        ? undefined
+        : /^Non-fat file:/mu.test(lipo.stdout)
+            ? 0
+            : (architectures.find(({ name }) => name === selectedArchitectureName)
+                ?.file_offset ?? undefined);
+    const normalized = normalizeMacho(captures, context.invocation, limitations, load, architectures, context.target.path, {
+        name: selectedArchitectureName,
+        container_file_offset: containerOffset ?? null,
+    });
+    const result = containerOffset === undefined
+        ? inspectMachoSchema.parse({
+            ...normalized,
+            limitations: [
+                ...normalized.limitations,
+                selectedArchitectureName === null
+                    ? "The selected Mach-O slice is unknown; slice-based evidence locations are unavailable."
+                    : "The selected Mach-O slice's container file offset was not observed; slice-based evidence locations are unavailable.",
+            ],
+        })
+        : normalized;
+    return ok({
+        result: jsonValueSchema.parse(result),
+        limitations: result.limitations,
+        locations: fileOffsetLocations(result, containerOffset),
+    });
+};
+const normalizeMacho = (captures, toInvocation, additionalLimitations, load, architectures, artifactPath, selectedArchitecture) => {
+    const byTool = captureLookup(captures);
+    const imports = parseDyldSymbols(sliceOutput(byTool("dyld_info", 0)), "imports");
+    const imageBase = load.segments.find((segment) => segment.file_offset === 0 && (segment.file_size ?? 0) > 0)?.vm_address ?? null;
+    const nmExports = parseNmExports(byTool("nm").stdout);
+    const dyldExports = parseDyldSymbols(sliceOutput(byTool("dyld_info", 1)), "exports", imageBase, new Set(nmExports.map(({ name }) => name)));
+    const exports = uniqueSymbols([...dyldExports, ...nmExports]);
+    const dwarfdump = byTool("dwarfdump");
+    const uuid = reconcileMachoUuid(load.commands, dwarfdump.stdout, artifactPath, selectedArchitecture.name);
+    const provenance = captures.map(toInvocation);
+    // A thread-state command carries the entrypoint in architecture-specific
+    // register state, so an absent decoded offset means unknown, not absent.
+    const threadEntrypoint = load.entrypoints.length === 0 &&
+        load.commands.some((command) => command.kind === "LC_UNIXTHREAD" || command.kind === "LC_THREAD");
+    const threadEntrypointLimitation = "Thread-state entrypoints (LC_UNIXTHREAD/LC_THREAD) are retained as raw load commands; file offsets are not derived.";
+    const limitations = [
+        "Imports and exports combine dyld_info and nm; stripped or toolchain-hidden symbols may be absent.",
+        ...(captures.some(({ tool }) => tool === "vtool")
+            ? [
+                "vtool output is retained as provenance but only otool build metadata is normalized.",
+            ]
+            : []),
+        ...additionalLimitations,
+        ...uuid.limitations,
+        ...(threadEntrypoint ? [threadEntrypointLimitation] : []),
+        ...(imageBase === null &&
+            /^\s*offset\s+symbol\s*$/mu.test(sliceOutput(byTool("dyld_info", 1)))
+            ? [
+                "Export virtual addresses are unavailable because no file-backed image base was observed.",
+            ]
+            : []),
+    ];
+    return inspectMachoSchema.parse({
+        format: "mach-o",
+        selected_architecture: selectedArchitecture,
+        endian: parseEndian(byTool("file").stdout),
+        word_size: parseWordSize(byTool("file").stdout),
+        file_type: load.fileType,
+        flags: load.flags,
+        uuid: uuid.value,
+        entrypoints: covered(load.entrypoints, !threadEntrypoint, threadEntrypoint ? [threadEntrypointLimitation] : []),
+        architectures: covered(architectures, true),
+        build_metadata: covered(load.builds, true),
+        load_commands: covered(load.commands, true),
+        dependencies: covered(load.dependencies, true),
+        imports: covered(imports, false, [
+            "dyld_info textual imports may omit chained or toolchain-unsupported metadata.",
+        ]),
+        exports: covered(exports, false, [
+            "Merged nm/dyld_info results may be incomplete for stripped binaries.",
+        ]),
+        segments: covered(load.segments.map((segment) => ({
+            ...segment,
+            sections: covered(segment.sections, true),
+        })), true),
+        provenance,
+        limitations,
+    });
+};
+/** Slice output without the echoed operand path, which can contain any text. */
+const sliceOutput = (capture) => withoutEchoedPathHeader(capture.stdout, capture.arguments.at(-1));
+const captureLookup = (captures) => (tool, occurrence = 0) => {
+    const capture = captures.filter((item) => item.tool === tool)[occurrence];
+    if (capture === undefined)
+        throw new TypeError(`Missing ${tool} capture`);
+    return capture;
+};
+const parseNmExports = (output) => output
+    .split(/\r?\n/u)
+    .filter((name) => name.length > 0)
+    .map((name) => ({
+    name,
+    address: null,
+    weak: null,
+    reexport: null,
+    source: "nm",
+}));
+const parseEndian = (output) => /little-endian/iu.test(output)
+    ? "little"
+    : /big-endian/iu.test(output)
+        ? "big"
+        : null;
+const parseWordSize = (output) => /64-bit/iu.test(output) ? 64 : /32-bit/iu.test(output) ? 32 : null;
+const covered = (items, exhaustive, limitations = []) => ({
+    items: [...items],
+    total: exhaustive ? items.length : null,
+    exhaustive,
+    limitations: [...limitations],
+});
+const uniqueSymbols = (items) => {
+    const unique = new Map();
+    for (const item of items)
+        if (!unique.has(item.name))
+            unique.set(item.name, item);
+    return [...unique.values()].sort((left, right) => compareUnicodeCodePoints(left.name, right.name));
+};
+const fileOffsetLocations = (macho, containerOffset) => {
+    const locations = architectureLocations(macho.architectures.items);
+    if (containerOffset === undefined)
+        return locations;
+    for (const entrypoint of macho.entrypoints.items)
+        locations.push({
+            kind: "file-offset",
+            offset: containerOffset + entrypoint.file_offset,
+        });
+    for (const segment of macho.segments.items) {
+        if (segment.file_offset === null ||
+            segment.file_size === null ||
+            segment.file_size === 0)
+            continue;
+        locations.push({
+            kind: "file-offset-range",
+            start: containerOffset + segment.file_offset,
+            end: containerOffset + segment.file_offset + segment.file_size,
+        });
+    }
+    return locations;
+};
+/** Project architecture slices into evidence file-offset locations. */
+export const architectureLocations = (architectures) => {
+    const locations = [];
+    for (const { file_offset: offset, size } of architectures) {
+        if (offset === null)
+            continue;
+        locations.push(size === null
+            ? { kind: "file-offset", offset }
+            : { kind: "file-offset-range", start: offset, end: offset + size });
+    }
+    return locations;
+};
+const selectedArchitectureArguments = (tool, architecture) => {
+    if (architecture === null)
+        return [];
+    const baseArchitecture = architecture.split(".")[0] ?? architecture;
+    // dyld_info distinguishes arm64e ABI variants; the other Apple tools use
+    // the base CPU-family spelling for the same slice.
+    const toolArchitecture = tool === "dyld_info" ? architecture : baseArchitecture;
+    return tool === "dwarfdump"
+        ? [`--arch=${toolArchitecture}`]
+        : ["-arch", toolArchitecture];
+};
+const selectArchitecture = (target, available) => {
+    if (target.kind !== "executable" || target.availableArchitectures.length < 2)
+        return { status: "unfiltered" };
+    const normalized = target.architecture === "x86" ? "i386" : target.architecture;
+    if (available.includes(normalized))
+        return { status: "selected", architecture: normalized };
+    // BinaryTarget intentionally normalizes ARM64 CPU subtypes. Recover the
+    // concrete arm64e slice name from lipo before invoking slice-aware tools.
+    if (normalized === "arm64") {
+        const arm64e = available.find((architecture) => architecture === "arm64e");
+        if (arm64e !== undefined)
+            return { status: "selected", architecture: arm64e };
+        const variant = available.find((architecture) => /^arm64e\.[A-Za-z0-9_]+$/u.test(architecture));
+        if (variant !== undefined)
+            return { status: "selected", architecture: variant };
+    }
+    return { status: "absent", architecture: normalized };
+};

package/dist/native/NativeUiHelperRuntime.js

@@ -0,0 +1,66 @@
+import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
+import { mkdir, mkdtemp, rm, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { SWIFTC_INTERRUPT } from "../process/DarwinProcessRunTokenReader.js";
+import { execFileOutput } from "../process/ExecFileOutput.js";
+import { safeParseJson } from "../domain/safeJson.js";
+import { NATIVE_UI_HELPER_MAX_BUFFER } from "./NativeUiOutputBudget.js";
+/** Lazily compile one owned helper per observation/scenario and remove its compiler cache. */
+export const createNativeUiHelperRuntime = (environment) => {
+    const selectedEnvironment = snapshotEnvironment(environment);
+    let root;
+    let executable;
+    const invoke = async (parameters, signal) => {
+        if (executable === undefined) {
+            root = await mkdtemp(join(tmpdir(), "rea-native-ui-"));
+            const output = join(root, "observer");
+            const main = join(root, "main.swift");
+            await symlink(fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", import.meta.url)), main);
+            // Keep swiftc's intermediate objects inside the removable root.
+            const compilerTemporary = join(root, "tmp");
+            await mkdir(compilerTemporary);
+            await execFileOutput("/usr/bin/xcrun", [
+                "swiftc",
+                "-module-cache-path",
+                join(root, "modules"),
+                fileURLToPath(new URL("../../bridge/native/NativeUIChildren.swift", import.meta.url)),
+                main,
+                "-o",
+                output,
+            ], {
+                timeout: 60_000,
+                maxBuffer: 1024 * 1024,
+                stopSignal: SWIFTC_INTERRUPT,
+                env: { ...selectedEnvironment, TMPDIR: compilerTemporary },
+                ...(signal === undefined ? {} : { signal }),
+            });
+            executable = output;
+        }
+        const output = await execFileOutput(executable, [JSON.stringify(parameters)], {
+            timeout: 30_000,
+            maxBuffer: NATIVE_UI_HELPER_MAX_BUFFER,
+            stopSignal: "SIGTERM",
+            env: selectedEnvironment,
+            ...(signal === undefined ? {} : { signal }),
+        });
+        const parsed = safeParseJson(output.stdout);
+        if (!parsed.ok)
+            throw new Error(`Native helper returned invalid JSON: ${parsed.error}`, {
+                cause: parsed.cause,
+            });
+        return parsed.value;
+    };
+    return {
+        invoke,
+        close: async () => {
+            if (root !== undefined) {
+                await rm(root, { recursive: true, force: true });
+                root = undefined;
+                executable = undefined;
+            }
+        },
+        resources: () => (root === undefined ? [] : [root]),
+    };
+};

package/dist/native/NativeUiObservation.js

@@ -0,0 +1,183 @@
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { isMachOFormat, } from "../domain/binaryTargetTypes.js";
+import { nativeUiObservationInputSchema, nativeUiScenarioInputSchema, nativeUiSnapshotSchema, nativeUiResultSchema, } from "../domain/native/nativeUiObservation.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { err, ok } from "../domain/result.js";
+import { createNativeUiHelperRuntime, } from "./NativeUiHelperRuntime.js";
+import { NATIVE_UI_OUTPUT_BUDGET_BYTES, NATIVE_UI_OUTPUT_WEIGHT, } from "./NativeUiOutputBudget.js";
+const helper = fileURLToPath(new URL("../../bridge/native/ReaNativeUI.swift", import.meta.url));
+const responseSchema = z.discriminatedUnion("ok", [
+    z.strictObject({ ok: z.literal(true), result: nativeUiSnapshotSchema }),
+    z.strictObject({
+        ok: z.literal(false),
+        code: z.string(),
+        message: z.string(),
+    }),
+]);
+/** Capture a selected existing app window and run explicitly selected scenarios. */
+export const observeNativeUi = async (target, operation, parameters, options) => {
+    const runtime = options.runtime ?? createNativeUiHelperRuntime(options.environment);
+    try {
+        return await observeWithHelper(target, operation, parameters, {
+            ...options,
+            invoke: options.invoke ?? runtime.invoke,
+        });
+    }
+    finally {
+        if (options.runtime === undefined)
+            await runtime.close();
+    }
+};
+const observeWithHelper = async (target, operation, parameters, options) => {
+    const parsed = (operation === "observe_native_ui"
+        ? nativeUiObservationInputSchema
+        : nativeUiScenarioInputSchema).safeParse(parameters);
+    if (!parsed.success)
+        return err(new AnalysisInputError(operation, { cause: parsed.error }));
+    if (target.kind !== "executable" || !isMachOFormat(target.format))
+        return err(new AnalysisCapabilityUnavailableError("native-macos", operation, "Native UI observation requires an active Mach-O executable or app target"));
+    const input = parsed.data;
+    if (!input.screenshot && !input.accessibility)
+        return err(new AnalysisInputError(operation, {
+            cause: new Error("Enable screenshot or accessibility capture"),
+        }));
+    const steps = operation === "capture_native_ui_scenario"
+        ? nativeUiScenarioInputSchema.parse(parameters).steps
+        : [];
+    const signal = options.signal === undefined
+        ? AbortSignal.timeout(180_000)
+        : AbortSignal.any([options.signal, AbortSignal.timeout(180_000)]);
+    const invoke = options.invoke;
+    let launchTime;
+    let outputBytes = 0;
+    const take = async (action) => {
+        if (signal.aborted)
+            return err(new AnalysisCancelledError(operation));
+        try {
+            const response = responseSchema.parse(await invoke({
+                pid: input.pid,
+                window_id: input.window_id,
+                executable: target.path,
+                sha256: target.sha256,
+                ...(launchTime === undefined ? {} : { launch_time: launchTime }),
+                screenshot: input.screenshot,
+                accessibility: input.accessibility,
+                max_nodes: input.max_nodes,
+                ...(action === undefined ? {} : { action }),
+            }, signal));
+            if (!response.ok)
+                return err(new AnalysisCapabilityUnavailableError("native-macos", operation, `${response.code}: ${response.message}`));
+            if (response.result.window.pid !== input.pid ||
+                response.result.window.window_id !== input.window_id ||
+                response.result.window.executable !== target.path ||
+                (launchTime !== undefined &&
+                    response.result.window.launch_time !== launchTime))
+                return err(new AnalysisCapabilityUnavailableError("native-macos", operation, "Native helper returned a different target process or window"));
+            launchTime = response.result.window.launch_time;
+            outputBytes +=
+                NATIVE_UI_OUTPUT_WEIGHT *
+                    Buffer.byteLength(JSON.stringify(response.result));
+            if (outputBytes > NATIVE_UI_OUTPUT_BUDGET_BYTES)
+                return err(new AnalysisCapabilityUnavailableError("native-macos", operation, "Scenario captures exceeded the 64 MiB output budget"));
+            return ok(response.result);
+        }
+        catch (cause) {
+            return err(signal.aborted
+                ? new AnalysisCancelledError(operation)
+                : new ProviderAdapterError("native-macos", operation, {
+                    cause,
+                    diagnostics: {
+                        helper_path: helper,
+                        reason: cause instanceof Error ? cause.message : String(cause),
+                        remediation: "Native helper failed, timed out, or returned malformed capture data; install compatible Xcode command-line tools and inspect local OS permissions",
+                    },
+                }));
+        }
+    };
+    const initial = await take();
+    if (!initial.ok)
+        return initial;
+    const results = [];
+    let before = initial.value;
+    for (const [index, step] of steps.entries()) {
+        if (signal.aborted) {
+            results.push({
+                index,
+                kind: step.kind,
+                before,
+                after: null,
+                outcome: "cancelled",
+                reason: "Scenario cancelled before action",
+            });
+            break;
+        }
+        if (step.kind === "wait") {
+            try {
+                await new Promise((resolve, reject) => {
+                    const abort = () => {
+                        clearTimeout(timer);
+                        reject(new Error("cancelled"));
+                    };
+                    const timer = setTimeout(() => {
+                        signal.removeEventListener("abort", abort);
+                        resolve();
+                    }, step.milliseconds);
+                    signal.addEventListener("abort", abort, { once: true });
+                    if (signal.aborted)
+                        abort();
+                });
+            }
+            catch (cause) {
+                // Cancellation is recorded as a cancelled outcome.
+                void cause;
+                results.push({
+                    index,
+                    kind: step.kind,
+                    before,
+                    after: null,
+                    outcome: "cancelled",
+                    reason: "Scenario cancelled during wait",
+                });
+                break;
+            }
+        }
+        const after = await take(step.kind === "wait" ? undefined : step);
+        if (!after.ok) {
+            results.push({
+                index,
+                kind: step.kind,
+                before,
+                after: null,
+                outcome: after.error._tag === "AnalysisCancelledError"
+                    ? "cancelled"
+                    : "failed",
+                reason: after.error.message,
+            });
+            break;
+        }
+        results.push({
+            index,
+            kind: step.kind,
+            before,
+            after: after.value,
+            outcome: "completed",
+            reason: null,
+        });
+        before = after.value;
+    }
+    return ok(nativeUiResultSchema.parse({
+        target_sha256: target.sha256,
+        initial: initial.value,
+        steps: results,
+        restore: "leave-as-is",
+        limitations: [
+            "Only the explicitly selected already-running process/window is admitted. REA starts no target process and does not change permissions, foreground applications, or restore application data.",
+            "Click uses AXPress; scroll uses AXIncrement/AXDecrement; key-entry sets the selected element's AXValue. Unsupported elements fail without global event fallback.",
+            "Each completed action is followed immediately by capture; delayed UI changes require explicit wait steps. A failed after-capture can follow a completed action, so failure does not prove absence of application effects.",
+            "Scenarios can change app data, cause app network activity and persist changes. The caller explicitly chooses leave-as-is; automatic restoration is unsupported.",
+            "Window matching uses exact PID and window ID for screenshots and unique accessibility geometry. Accessibility paths can change as the UI changes; stale or ambiguous paths fail. Screenshots are scaled to at most 2048 pixels; scenario output is budgeted at 64 MiB and execution is cancelled after 180 seconds.",
+        ],
+    }));
+};

package/dist/native/NativeUiOutputBudget.js

@@ -0,0 +1,8 @@
+const HELPER_SUCCESS_WRAPPER = Buffer.from(JSON.stringify({ ok: true, result: {} }));
+/** Scenario output is charged at twice the encoded result size before return. */
+export const NATIVE_UI_OUTPUT_BUDGET_BYTES = 64 * 1024 * 1024;
+export const NATIVE_UI_OUTPUT_WEIGHT = 2;
+/** Bytes added around a result by the helper's success JSON response. */
+export const NATIVE_UI_HELPER_ENVELOPE_BYTES = HELPER_SUCCESS_WRAPPER.byteLength - Buffer.byteLength("{}");
+/** Raw helper output is bounded by the scenario's existing unweighted byte budget. */
+export const NATIVE_UI_HELPER_MAX_BUFFER = NATIVE_UI_OUTPUT_BUDGET_BYTES + NATIVE_UI_HELPER_ENVELOPE_BYTES;