rea-agents 6.4.0 → 6.7.0

package/dist/cliOutput.js

@@ -1,24 +1,77 @@
 const UNSUPPORTED_OUTPUT_COMBINATION_MESSAGE = "Token windows cannot preserve structured output. Remove --token-limit/--token-offset and use --filter-output or command pagination.";
 const INCUR_OUTPUT_FORMATS = new Set(["toon", "json", "yaml", "md", "jsonl"]);
+/** Global output flags that take a value. */
+const VALUED_OUTPUT_FLAGS = new Set([
+    "--format",
+    "--filter-output",
+    "--token-limit",
+    "--token-offset",
+]);
+const ROOT_UPDATE_OUTPUT_FLAGS = new Set([
+    "--json",
+    "--full-output",
+    "--token-count",
+]);
+/**
+ * Route the root update alias and split `--flag=value` output forms. Incur reads these
+ * flags only in spaced form, so `--format=json` otherwise reaches the command
+ * parser and fails as an unknown flag. Command options accept both forms.
+ */
+export const normalizeCliArguments = (arguments_) => {
+    const normalized = [];
+    const updates = new Set();
+    let rootUpdate = true;
+    for (let index = 0; index < arguments_.length; index += 1) {
+        const argument = arguments_[index];
+        if (VALUED_OUTPUT_FLAGS.has(argument) && arguments_[index + 1]) {
+            // Incur consumes a nonempty spaced value before looking for more flags.
+            // Its contents belong to that option, even when they look like a flag.
+            normalized.push(argument, arguments_[index + 1]);
+            index += 1;
+            continue;
+        }
+        const separator = argument.indexOf("=");
+        const flag = argument.slice(0, separator);
+        if (separator >= 0 && VALUED_OUTPUT_FLAGS.has(flag))
+            normalized.push(flag, argument.slice(separator + 1));
+        else {
+            if (argument === "--update")
+                updates.add(normalized.length);
+            else if (!ROOT_UPDATE_OUTPUT_FLAGS.has(argument))
+                rootUpdate = false;
+            normalized.push(argument);
+        }
+    }
+    // Output option values were consumed above; flag-shaped data is never an alias.
+    // Help/check/command/unknown tokens retain Incur's parsing and precedence.
+    return rootUpdate && updates.size > 0
+        ? ["update", ...normalized.filter((_, index) => !updates.has(index))]
+        : normalized;
+};
 /** Read effective Incur output controls at the executable boundary. */
 export const parseCliOutputArguments = (arguments_) => {
     let format = "toon";
     let filterOutput;
     let fullOutput = false;
+    let missingValue;
     let tokenCount = false;
-    let tokenWindow = false;
+    let tokenLimit;
+    let tokenOffset;
     const parsed = (parseError) => ({
         filterOutput,
         format,
         fullOutput,
+        missingValue,
         parseError,
         tokenCount,
-        tokenWindow: parseError ? false : tokenWindow,
+        tokenWindow: !parseError && (tokenLimit !== undefined || tokenOffset !== undefined),
+        tokenLimit: parseError ? undefined : tokenLimit,
+        tokenOffset: parseError ? undefined : tokenOffset,
     });
     for (let index = 0; index < arguments_.length; index += 1) {
         const argument = arguments_[index];
-        // Incur scans builtins across `--` and accepts only spaced value forms.
-        // Mirror those effective values at the executable output boundary.
+        // Incur scans builtins across `--` and reads spaced value forms, which
+        // normalizeCliArguments has produced. Mirror those effective values.
         if (argument === "--json") {
             format = "json";
             continue;
@@ -33,6 +86,8 @@ export const parseCliOutputArguments = (arguments_) => {
                 format = value;
                 index += 1;
             }
+            else
+                missingValue ??= argument;
             continue;
         }
         if (argument === "--filter-output") {
@@ -40,6 +95,8 @@ export const parseCliOutputArguments = (arguments_) => {
                 filterOutput = arguments_[index + 1];
                 index += 1;
             }
+            else
+                missingValue ??= argument;
             continue;
         }
         if (argument === "--token-limit" || argument === "--token-offset") {
@@ -48,9 +105,14 @@ export const parseCliOutputArguments = (arguments_) => {
                 const numericValue = Number(value);
                 if (!Number.isFinite(numericValue) || value.trim() === "")
                     return parsed(true);
-                tokenWindow = true;
+                if (argument === "--token-limit")
+                    tokenLimit = numericValue;
+                else
+                    tokenOffset = numericValue;
                 index += 1;
             }
+            else
+                missingValue ??= argument;
             continue;
         }
         if (argument === "--full-output")
@@ -60,11 +122,38 @@ export const parseCliOutputArguments = (arguments_) => {
     }
     return parsed(false);
 };
-/** Reject text-window controls that would corrupt a structured document. */
+/** Reject slices that cannot advance within Incur's comma-delimited paths. */
+const hasUnclosedFilterSlice = (expression) => {
+    let depth = 0;
+    let unclosed = false;
+    for (const character of expression) {
+        if (character === "[") {
+            depth += 1;
+            unclosed = true;
+        }
+        else if (character === "]") {
+            depth -= 1;
+            // Incur consumes everything through the next closing bracket, including
+            // nested opening brackets. Do not impose a different filter grammar.
+            unclosed = false;
+        }
+        else if (character === "," && depth === 0 && unclosed)
+            return true;
+    }
+    return unclosed;
+};
+/** Reject output controls that cannot safely produce a complete result. */
 export const validateCliOutputArguments = (arguments_) => {
-    const { format, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
+    const { filterOutput, format, missingValue, parseError, tokenWindow } = parseCliOutputArguments(arguments_);
     if (parseError)
         return { ok: true };
+    if (filterOutput !== undefined && hasUnclosedFilterSlice(filterOutput))
+        return {
+            ok: false,
+            format: format === "yaml" || format === "jsonl" ? format : "json",
+            code: "INVALID_OUTPUT_FILTER",
+            message: "The --filter-output expression has a slice without a closing ]. Close the slice or remove --filter-output.",
+        };
     if (tokenWindow &&
         (format === "json" || format === "jsonl" || format === "yaml"))
         return {
@@ -73,6 +162,15 @@ export const validateCliOutputArguments = (arguments_) => {
             code: "UNSUPPORTED_OUTPUT_COMBINATION",
             message: UNSUPPORTED_OUTPUT_COMBINATION_MESSAGE,
         };
+    // Incur skips a valued flag without a value and then reports the flag
+    // itself as unknown. Name the missing value instead.
+    if (missingValue !== undefined)
+        return {
+            ok: false,
+            format: format === "yaml" || format === "jsonl" ? format : "json",
+            code: "MISSING_OUTPUT_VALUE",
+            message: `${missingValue} requires a value, as in ${missingValue} <value> or ${missingValue}=<value>.`,
+        };
     return { ok: true };
 };
 /** Preserve a complete document when Incur filters the entire result away. */

package/dist/composition/binary.js

@@ -1,7 +1,9 @@
+import { isAppleDispatchMetadataTarget } from "../domain/native/objcSwiftMetadata.js";
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { HopperProvider } from "../hopper/HopperProvider.js";
 import { GhidraProvider } from "../ghidra/GhidraProvider.js";
 import { IdaProvider } from "../ida/IdaProvider.js";
+import { KunaProvider } from "../kuna/KunaProvider.js";
 import { auxiliaryAnalysisProviderDeclarations } from "./auxiliaryAnalysisProviders.js";
 import { AnalysisProviderRegistry } from "../application/binary/AnalysisProviderRegistry.js";
 import { composeBinarySession } from "../application/binary/BinarySessionComposition.js";
@@ -12,14 +14,29 @@ import { ManagedStaticProvider } from "../dotnet/ManagedStaticProvider.js";
  * This is the sole production wiring point, so both adapters share identical
  * provider selection, profile, lifecycle, and Evidence semantics.
  */
-export const createBinarySession = (config, logger, selectedEnvironment) => {
+export const createBinarySession = (config, logger, selectedEnvironment) => composeDeepBinarySession(config, logger, selectedEnvironment);
+/** Prefer byte-backed dispatch inspection while retaining deep symbol fallback. */
+export const createNativeDispatchBinarySession = (config, logger, selectedEnvironment) => composeDeepBinarySession(config, logger, selectedEnvironment, "inspect_native_dispatch_metadata");
+const composeDeepBinarySession = (config, logger, selectedEnvironment, inspection) => {
     const environment = snapshotEnvironment(selectedEnvironment);
     const hopper = new HopperProvider(config, logger, environment);
     const ghidra = new GhidraProvider(config, logger, environment);
     const ida = new IdaProvider(config, environment);
-    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida], config.analysisProvider), auxiliaryAnalysisProviderDeclarations(environment).map((declaration) => new LazyAnalysisProvider(declaration)));
+    const kuna = new KunaProvider(environment);
+    const auxiliaryDeclarations = auxiliaryAnalysisProviderDeclarations(environment);
+    const nativeInspectionAvailable = inspection !== undefined &&
+        auxiliaryDeclarations.some(({ capabilities }) => capabilities.some(({ operation, available }) => operation === inspection && available));
+    return composeBinarySession(new AnalysisProviderRegistry([hopper, ghidra, ida, kuna], config.analysisProvider, nativeInspectionAvailable ? isAppleDispatchMetadataTarget : undefined), auxiliaryDeclarations.map((declaration) => new LazyAnalysisProvider(declaration)));
 };
 /** Compose an execution-free managed session without native provider selection. */
 export const createManagedBinarySession = () => composeBinarySession(new AnalysisProviderRegistry([]), [
     new ManagedStaticProvider(),
 ]);
+/** Compose the artifact operations without candidates for deep analysis engines. */
+export const createArtifactBinarySession = (selectedEnvironment, platform = process.platform) => import("../artifacts/ArtifactProvider.js").then(({ ArtifactProvider }) => composeBinarySession(new AnalysisProviderRegistry([]), [
+    new ArtifactProvider(snapshotEnvironment(selectedEnvironment, platform), platform),
+]));
+/** Compose native inspection utilities without candidates for deep analysis. */
+export const createNativeBinarySession = (selectedEnvironment, platform = process.platform) => import("../native/NativeMacOSProvider.js").then(({ NativeMacOSProvider }) => composeBinarySession(new AnalysisProviderRegistry([]), [
+    new NativeMacOSProvider(snapshotEnvironment(selectedEnvironment, platform), undefined, platform),
+]));

package/dist/composition/captures.js

@@ -0,0 +1,3 @@
+import { PacketCaptureService } from "../application/captures/PacketCaptureService.js";
+import { TsharkCaptureProvider } from "../captures/TsharkCaptureProvider.js";
+export const createPacketCaptureService = (environment = process.env) => new PacketCaptureService(new TsharkCaptureProvider(environment));

package/dist/composition/directAnalysis.js

@@ -1,7 +1,5 @@
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { parseConfig } from "../config/parseConfig.js";
-import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
-import { runSessionStatus as executeSessionStatus } from "../application/DirectAnalysisStatus.js";
 /** Bind one-shot analysis and status commands to one caller-selected environment. */
 export const createDirectAnalysis = (selectedEnvironment) => {
     const environment = snapshotEnvironment(selectedEnvironment);
@@ -15,17 +13,44 @@ export const createDirectAnalysis = (selectedEnvironment) => {
             const { createManagedBinarySession } = await import("./binary.js");
             return createManagedBinarySession();
         },
+        createNativeDispatchBinarySession: async (config, logger) => {
+            const { createNativeDispatchBinarySession } = await import("./binary.js");
+            return createNativeDispatchBinarySession(config, logger, environment);
+        },
+        createNativeBinarySession: async () => {
+            const { createNativeBinarySession } = await import("./binary.js");
+            return createNativeBinarySession(environment);
+        },
+        createArtifactBinarySession: async () => {
+            const { createArtifactBinarySession } = await import("./binary.js");
+            return createArtifactBinarySession(environment);
+        },
+    };
+    const runDirectAnalysis = async (...args) => {
+        const { runDirectAnalysis } = await import("../application/DirectAnalysis.js");
+        return runDirectAnalysis(dependencies, ...args);
+    };
+    const runProviderAnalysis = async (...args) => {
+        const { runProviderAnalysis } = await import("../application/DirectAnalysis.js");
+        return runProviderAnalysis(dependencies, ...args);
+    };
+    const runSessionStatus = async (...args) => {
+        const { runSessionStatus } = await import("../application/DirectAnalysisStatus.js");
+        return runSessionStatus(dependencies, ...args);
     };
     return {
-        runDirectAnalysis: executeDirectAnalysis.bind(undefined, dependencies),
-        runProviderAnalysis: executeProviderAnalysis.bind(undefined, dependencies),
-        runSessionStatus: executeSessionStatus.bind(undefined, dependencies),
+        runDirectAnalysis,
+        runProviderAnalysis,
+        runSessionStatus,
     };
 };
 /** Execute managed metadata without configuration or native provider candidates. */
-export const runManagedProviderExecution = executeManagedProvider.bind(undefined, {
-    createManagedBinarySession: async () => {
-        const { createManagedBinarySession } = await import("./binary.js");
-        return createManagedBinarySession();
-    },
-});
+export const runManagedProviderExecution = async (...args) => {
+    const { runManagedProviderExecution } = await import("../application/DirectAnalysis.js");
+    return runManagedProviderExecution({
+        createManagedBinarySession: async () => {
+            const { createManagedBinarySession } = await import("./binary.js");
+            return createManagedBinarySession();
+        },
+    }, ...args);
+};

package/dist/composition/electronFuses.js

@@ -0,0 +1,4 @@
+import { ElectronFuseService } from "../application/electron/ElectronFuseService.js";
+import { ElectronFuseProvider } from "../electron/ElectronFuseProvider.js";
+/** Compose read-only fuse inspection without a runtime, network, or fuse edit. */
+export const createElectronFuseService = () => new ElectronFuseService(new ElectronFuseProvider());

package/dist/composition/evm.js

@@ -1,4 +1,16 @@
 import { EvmInterfaceService } from "../application/evm/EvmInterfaceService.js";
 import { EvmoleInterfaceProvider } from "../evm/EvmoleInterfaceProvider.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+import { INSPECT_EVM_INTERFACE_CONTRACT } from "../contracts/evm/evmToolContracts.js";
 /** Compose offline interface analysis without import-time I/O or dependency acquisition. */
 export const createEvmInterfaceService = (environment = process.env) => new EvmInterfaceService(new EvmoleInterfaceProvider(environment));
+/**
+ * Static binding of the existing operation, command and fresh service factory.
+ * The host owns injected service identity and its retryable cleanup lifetime.
+ * Construction performs no acquisition, target I/O or import-time execution.
+ */
+export const evmInterfaceModule = {
+    contract: INSPECT_EVM_INTERFACE_CONTRACT,
+    cliCommand: CLI_COMMANDS.inspectEvmInterface,
+    create: createEvmInterfaceService,
+};

package/dist/composition/flutter.js

@@ -0,0 +1,3 @@
+import { FlutterBuildProvider } from "../flutter/FlutterBuildProvider.js";
+/** Construct one Flutter provider; it needs no external tools. */
+export const createFlutterBuildAnalysisProvider = () => new FlutterBuildProvider();

package/dist/composition/go.js

@@ -0,0 +1,4 @@
+import { GoBinaryService } from "../application/go/GoBinaryService.js";
+import { GoBinaryProvider } from "../go/GoBinaryProvider.js";
+/** Compose bundled offline inspection without acquiring a toolchain or starting any process. */
+export const createGoBinaryService = () => new GoBinaryService(new GoBinaryProvider());

package/dist/composition/javascriptAnalysisWorkerProcess.js

@@ -1,14 +1,15 @@
+import { moduleResolutionModeForJavaScriptReference } from "../domain/javascript/javascriptModuleResolutionMode.js";
 import { parseJavaScriptSource } from "../domain/javascript/javascriptSourceParser.js";
 import { analyzeParsedJavaScriptStaticSourceSteps } from "../domain/javascript/javascriptStaticAnalysis.js";
-import { analyzeParsedJavaScriptSemanticsSteps, classifyParsedJavaScriptOpenReceiversSteps, } from "../domain/javascript/javascriptSemanticAnalysis.js";
+import { analyzeParsedJavaScriptSemanticsSteps } from "../domain/javascript/javascriptSemanticAnalysis.js";
 import { failedJavaScriptStaticAnalysis } from "../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { projectJavaScriptModuleSemantics } from "../domain/javascript/javascriptModuleSemanticIr.js";
-import { measureJavaScriptModuleTransfer } from "../javascript/analysis/JavaScriptAnalysisTransfer.js";
+import { javaScriptTransferByteBudget, measureJavaScriptModuleTransfer, } from "../javascript/analysis/JavaScriptAnalysisTransfer.js";
 import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
 import { projectJavaScriptSemanticFileSteps } from "../application/javascript/JavaScriptSemanticGraphBuilder.js";
 import { completeJavaScriptAnalysisSteps } from "../application/javascript/JavaScriptAnalysisControl.js";
 import { serveJavaScriptAnalysisWorker, } from "../javascript/analysis/JavaScriptAnalysisWorkerServer.js";
-const analyze = async (file, nodeBudget, callbacks) => {
+const analyze = async (file, capacity, callbacks) => {
     if (!file.text.included)
         throw new TypeError("JavaScript worker requires decoded source text");
     await callbacks.phase("parse");
@@ -18,25 +19,24 @@ const analyze = async (file, nodeBudget, callbacks) => {
         return null;
     }
     await callbacks.phase("static");
-    const receivers = await completeJavaScriptAnalysisSteps(classifyParsedJavaScriptOpenReceiversSteps(parsed));
-    const facts = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, receivers));
+    const facts = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed));
     const resultBudgetBytes = await callbacks.checkpoint(facts);
     if (facts.parse_status === "failed")
         return null;
     if (resultBudgetBytes === 0)
         throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `The parent reserved its remaining result capacity for static observations; semantic analysis of ${file.path} was not started`, { semantic_result_budget_bytes: 0 });
     await callbacks.phase("semantic");
-    const ir = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptSemanticsSteps(parsed));
+    const ir = await completeJavaScriptAnalysisSteps(analyzeParsedJavaScriptSemanticsSteps(parsed, moduleResolutionModeForJavaScriptReference(file.path, "static-import")));
     parsed = null;
     const module = projectJavaScriptModuleSemantics(ir);
-    const measured = measureJavaScriptModuleTransfer(module);
+    const measured = measureJavaScriptModuleTransfer(module, javaScriptTransferByteBudget(resultBudgetBytes));
     if (measured.retentionBytes > resultBudgetBytes)
         throw new AnalysisResourceConstraintError("analyze_javascript_application", "memory", `Completed module facts for ${file.path} exceed the parent's offered result budget; static facts were retained`, {
             semantic_result_budget_bytes: resultBudgetBytes,
             module_transfer_bytes: measured.bytes,
         });
     await callbacks.phase("projection");
-    const projection = await completeJavaScriptAnalysisSteps(projectJavaScriptSemanticFileSteps(file, ir, nodeBudget));
+    const projection = await completeJavaScriptAnalysisSteps(projectJavaScriptSemanticFileSteps(file, ir, capacity, facts.electron.call_paths));
     return { module, projection };
 };
 try {

package/dist/composition/jeb.js

@@ -1,6 +1,46 @@
+import { parseJebMcpTimeoutMs } from "../config/environment.js";
+import { ConfigurationError } from "../domain/configurationErrors.js";
+import { AnalysisInputError } from "../domain/analysisErrorCore.js";
+import { err } from "../domain/result.js";
 import { JebProvider } from "../jeb/JebProvider.js";
-/** Construct one JEB provider bound to the caller-selected MCP endpoint. */
-export const createJebAnalysisProvider = (environment = process.env, connectionFactory) => new JebProvider({
-    environment,
-    ...(connectionFactory === undefined ? {} : { connectionFactory }),
-});
+/**
+ * Construct one JEB provider bound to the caller-selected MCP endpoint. An
+ * unusable endpoint makes only JEB unavailable; every other CLI command and
+ * MCP tool is composed alongside it.
+ */
+export const createJebAnalysisProvider = (environment = process.env, connectionFactory) => {
+    const requestTimeout = parseJebMcpTimeoutMs(environment.REA_JEB_MCP_TIMEOUT_MS);
+    if (!requestTimeout.ok)
+        return unconfiguredJebProvider(requestTimeout.error);
+    try {
+        return new JebProvider({
+            environment,
+            ...(requestTimeout.value === undefined
+                ? {}
+                : { requestTimeoutMs: requestTimeout.value }),
+            ...(connectionFactory === undefined ? {} : { connectionFactory }),
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof AnalysisInputError))
+            throw cause;
+        const constraint = typeof cause.cause === "string" ? cause.cause : cause.message;
+        return unconfiguredJebProvider(new ConfigurationError("Invalid REA environment configuration", {
+            cause,
+            settings: [{ setting: "REA_JEB_MCP_URL", constraint }],
+        }));
+    }
+};
+const unconfiguredJebProvider = (error) => {
+    const setting = error.settings[0]?.setting ?? "REA_JEB_MCP_URL";
+    return {
+        inspectAvailability: () => Promise.resolve({
+            status: "unavailable",
+            code: "not_configured",
+            reason: `${setting} is invalid: ${error.settings[0]?.constraint ?? error.message}`,
+            diagnostics: { setting },
+        }),
+        close: () => Promise.resolve(),
+        execute: () => Promise.resolve(err(error)),
+    };
+};

package/dist/composition/pcap.js

@@ -0,0 +1,3 @@
+import { PcapProvider } from "../pcap/PcapProvider.js";
+/** Construct one pcap provider bound to the caller-selected tools. */
+export const createPcapAnalysisProvider = (environment = process.env) => new PcapProvider({ environment });

package/dist/composition/resolveWindowsProviderExecutable.js

@@ -0,0 +1,61 @@
+import { existsSync, statSync } from "node:fs";
+import { win32 } from "node:path";
+const splitWindowsPath = (value) => {
+    const entries = [];
+    let start = 0;
+    let quoted = false;
+    for (let index = 0; index < value.length; index += 1) {
+        if (value[index] === '"')
+            quoted = !quoted;
+        else if (value[index] === ";" && !quoted) {
+            entries.push(value.slice(start, index));
+            start = index + 1;
+        }
+    }
+    entries.push(value.slice(start));
+    return entries.flatMap((entry) => {
+        if (entry.startsWith('"') && entry.endsWith('"') && entry.length >= 2)
+            return [entry.slice(1, -1)];
+        return entry.includes('"') ? [] : [entry];
+    });
+};
+const isRegularFile = (path) => {
+    try {
+        return existsSync(path) && statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+/** Resolve Windows bare command names against the captured child environment. */
+export const resolveWindowsProviderExecutable = (executable, environment, lookup = {}) => {
+    const cwd = lookup.cwd ?? process.cwd();
+    const absolute = (...paths) => win32.resolve(cwd, ...paths);
+    if (win32.isAbsolute(executable) ||
+        executable.includes("/") ||
+        executable.includes("\\") ||
+        win32.parse(executable).root !== "")
+        return absolute(executable);
+    const pathValue = environment.PATH ?? environment.Path ?? environment.path;
+    if (pathValue === undefined)
+        return executable;
+    const pathEntries = splitWindowsPath(pathValue);
+    const explicitExtension = win32.extname(executable).toLowerCase();
+    if (explicitExtension !== "" && ![".com", ".exe"].includes(explicitExtension))
+        return executable;
+    const extensions = explicitExtension !== ""
+        ? [""]
+        : (environment.PATHEXT ?? environment.PathExt ?? ".COM;.EXE")
+            .split(";")
+            .filter((extension) => [".com", ".exe"].includes(extension.toLowerCase()));
+    for (const entry of pathEntries) {
+        if (entry.length === 0)
+            continue;
+        for (const extension of extensions) {
+            const candidate = absolute(entry, `${executable}${extension}`);
+            if ((lookup.isFile ?? isRegularFile)(candidate))
+                return candidate;
+        }
+    }
+    return executable;
+};

package/dist/composition/reverseEngineering.js

@@ -0,0 +1,29 @@
+import { ReverseEngineeringService } from "../application/reverse/ReverseEngineeringService.js";
+import { objdumpCommand, OBJDUMP_PROVIDER_IDENTITY, } from "../objdump/ObjdumpCommand.js";
+import { rizinCommand, RIZIN_PROVIDER_IDENTITY, } from "../rizin/RizinCommand.js";
+import { resolveWindowsProviderExecutable } from "./resolveWindowsProviderExecutable.js";
+export const createReverseEngineeringCommandPort = (environment, platform = process.platform) => ({
+    objdump: (input) => ({
+        executable: providerExecutable(environment.REA_OBJDUMP_COMMAND ?? "objdump", environment, platform),
+        arguments: objdumpCommand(input),
+        identity: OBJDUMP_PROVIDER_IDENTITY,
+        environmentOverrides: { DEBUGINFOD_URLS: "" },
+    }),
+    rizin: (input) => ({
+        executable: providerExecutable(environment.REA_RIZIN_COMMAND ?? "rizin", environment, platform),
+        arguments: rizinCommand(input),
+        identity: RIZIN_PROVIDER_IDENTITY,
+    }),
+});
+const providerExecutable = (executable, environment, platform) => platform === "win32"
+    ? resolveWindowsProviderExecutable(executable, environment)
+    : executable;
+/** Compose BYO reverse-engineering commands without acquiring tools at import time. */
+export const createReverseEngineeringService = (environment = process.env, options = {}) => {
+    const environmentSnapshot = { ...environment };
+    return new ReverseEngineeringService({
+        ...options,
+        environment: environmentSnapshot,
+        commands: createReverseEngineeringCommandPort(environmentSnapshot),
+    });
+};

package/dist/composition/rust.js

@@ -0,0 +1,4 @@
+import { RustBinaryService } from "../application/rust/RustBinaryService.js";
+import { RustBinaryProvider } from "../rust/RustBinaryProvider.js";
+/** Compose bundled offline inspection without a Rust toolchain or any child process. */
+export const createRustBinaryService = () => new RustBinaryService(new RustBinaryProvider());

package/dist/composition/signals.js

@@ -0,0 +1,3 @@
+import { SignalRecordingService } from "../application/signals/SignalRecordingService.js";
+import { SigrokRecordingProvider } from "../signals/SigrokRecordingProvider.js";
+export const createSignalRecordingService = (environment = process.env) => new SignalRecordingService(new SigrokRecordingProvider(environment));

package/dist/composition/sqlite.js

@@ -0,0 +1,4 @@
+import { SqliteDatabaseService } from "../application/sqlite/SqliteDatabaseService.js";
+import { SqliteDatabaseProvider } from "../sqlite/SqliteDatabaseProvider.js";
+/** Compose local snapshot inspection without opening a native analysis provider. */
+export const createSqliteDatabaseService = (environment = process.env) => new SqliteDatabaseService(new SqliteDatabaseProvider(environment));

package/dist/composition/wasm.js

@@ -0,0 +1,22 @@
+import { WasmArtifactService } from "../application/wasm/WasmArtifactService.js";
+import { WabtArtifactProvider } from "../wasm/WabtArtifactProvider.js";
+import { INSPECT_WASM_ARTIFACT_CONTRACT } from "../contracts/wasm/wasmToolContracts.js";
+import { CLI_COMMANDS } from "../cliCommandNames.js";
+/** Compose the caller-supplied offline toolchain without acquisition or import-time I/O. */
+export const createWasmArtifactService = (environment = process.env) => new WasmArtifactService(new WabtArtifactProvider(environment));
+/**
+ * Internal static descriptor for one named domain operation and its lifetime.
+ * CLI/MCP share this binding; the service keeps failed resource ownership so
+ * close can be retried. Construction performs no acquisition or target I/O.
+ */
+export const wasmArtifactModule = {
+    contract: INSPECT_WASM_ARTIFACT_CONTRACT,
+    cliCommand: CLI_COMMANDS.inspectWasmArtifact,
+    create(environment, injected) {
+        const service = injected ?? createWasmArtifactService(environment);
+        return {
+            inspect: service.inspect.bind(service),
+            close: service.close.bind(service),
+        };
+    },
+};

package/dist/composition/webNetworkCaptures.js

@@ -1,6 +1,11 @@
 import { WebNetworkCaptureService } from "../application/WebNetworkCaptureService.js";
 import { HistoricalCaptureDecoder } from "../browser/history/HistoricalCaptureDecoder.js";
-import { HarCaptureAdapter } from "../browser/history/HarCaptureAdapter.js";
+import { NodeCaptureAdapter } from "../browser/history/NodeCaptureAdapter.js";
 import { MitmproxyCaptureAdapter } from "../browser/history/MitmproxyCaptureAdapter.js";
 /** Compose offline format adapters without import-time reads, installation or process startup. */
-export const createWebNetworkCaptureService = (environment = process.env) => new WebNetworkCaptureService(new HistoricalCaptureDecoder([new HarCaptureAdapter(), new MitmproxyCaptureAdapter(environment)], environment));
+export const createWebNetworkCaptureService = (environment = process.env) => new WebNetworkCaptureService(new HistoricalCaptureDecoder([
+    new NodeCaptureAdapter("har"),
+    new NodeCaptureAdapter("saz"),
+    new NodeCaptureAdapter("qlog"),
+    new MitmproxyCaptureAdapter(environment),
+], environment));