@uipath/packager-tool-bpmn 1.202.0-preview.140 → 1.202.0-preview.142

package/package.json

@@ -1,13 +1,10 @@
 {
     "name": "@uipath/packager-tool-bpmn",
-    "version": "1.202.0-preview.140",
+    "version": "1.202.0-preview.142",
     "description": "UiPath ProcessOrchestration (BPMN) tool implementation",
     "type": "module",
     "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "default": "./dist/index.js"
-        }
+        ".": "./dist/index.js"
     },
     "repository": {
         "type": "git",
@@ -19,8 +16,7 @@
     },
     "types": "./dist/index.d.ts",
     "files": [
-        "dist",
-        "src"
+        "dist"
     ],
     "author": "",
     "license": "ISC",
@@ -30,5 +26,5 @@
     "dependencies": {
         "@uipath/maestro-sdk": "1.202.0"
     },
-    "gitHead": "1861498d8a158a710a718c04614523ba59c93781"
+    "gitHead": "2f7204440851d62ecc9f2d2e202c863293821d90"
 }

package/src/bpmn-tool-factory.ts

@@ -1,26 +0,0 @@
-import {
-    type IFileSystem,
-    type IProjectToolFactory,
-    type IToolLogger,
-    type ProjectTool,
-    type ProjectType,
-    ProjectTypes,
-} from "@uipath/solutionpackager-tool-core";
-import { BpmnTool } from "./bpmn-tool.js";
-
-/**
- * Factory for creating ProcessOrchestration (BPMN) project tools
- */
-export class BpmnToolFactory implements IProjectToolFactory {
-    readonly supportedTypes: readonly ProjectType[] = [
-        ProjectTypes.ProcessOrchestration,
-        "processOrchestration",
-    ];
-
-    async createAsync(
-        logger: IToolLogger,
-        fileSystem: IFileSystem,
-    ): Promise<ProjectTool> {
-        return new BpmnTool(fileSystem, logger);
-    }
-}

package/src/bpmn-tool.ts

@@ -1,632 +0,0 @@
-// Type-only: erases at build, so it does not put the module on the import path.
-import type {
-    BpmnPackageFile,
-    JsonObject,
-} from "@uipath/maestro-sdk/bpmn-packaging";
-import type { BpmnValidationFileSystem } from "@uipath/maestro-sdk/bpmn-validation";
-import { BpmnValidateService } from "@uipath/maestro-sdk/bpmn-validation";
-import type {
-    IProjectBuildOptions,
-    IProjectPackOptions,
-    IProjectRestoreOptions,
-    IProjectValidateOptions,
-    UiProject,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    ensureContentOperateFile,
-    type IFileSystem,
-    type IToolLogger,
-    NugetConstants,
-    NugetPackager,
-    Path,
-    ProjectTool,
-    ProjectTypes,
-    TemporaryStorageService,
-    ToolErrorCodes,
-    ToolResult,
-} from "@uipath/solutionpackager-tool-core";
-
-/**
- * BPMN-specific file names (same conventions as Flow)
- * ProcessOrchestration projects use 'entry-points.json' (with dash) and 'bindings_v2.json' (with underscore)
- */
-const BpmnConstants = {
-    EntryPointsFileName: "entry-points.json",
-    BindingsV2FileName: "bindings_v2.json",
-} as const;
-
-function createBpmnValidationFileSystem(
-    fileSystem: IFileSystem,
-): BpmnValidationFileSystem {
-    return {
-        readdir: (path) => fileSystem.readdir(path),
-        readFile: (path) => fileSystem.readFile(path),
-        exists: (path) => fileSystem.exists(path),
-        joinPath: (...segments) => Path.join(...segments),
-    };
-}
-
-/**
- * ProcessOrchestration (BPMN) project tool implementation
- */
-export class BpmnTool extends ProjectTool {
-    private readonly _temporaryStorage: TemporaryStorageService;
-    // Standalone `validate` keeps an extension type absent from the contract a
-    // warning, so authoring against a type newer than the CLI's bundled contract
-    // is not blocked.
-    private readonly _validateService: BpmnValidateService;
-    // Packaging must fail fast on such a type rather than ship a package
-    // Orchestrator rejects at deploy (Error 1654), so the build path validates
-    // with error severity.
-    private readonly _packValidateService: BpmnValidateService;
-
-    constructor(fileSystem: IFileSystem, logger: IToolLogger) {
-        super(fileSystem, logger);
-        this._temporaryStorage = new TemporaryStorageService(fileSystem);
-        const validationFileSystem = createBpmnValidationFileSystem(fileSystem);
-        this._validateService = new BpmnValidateService(validationFileSystem);
-        this._packValidateService = new BpmnValidateService(
-            validationFileSystem,
-            { unsupportedExtensionTypeSeverity: "error" },
-        );
-    }
-
-    override async restoreAsync(
-        _options: IProjectRestoreOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        this.logger.info(
-            "Restore operation is not required for ProcessOrchestration projects",
-        );
-        return ToolResult.success();
-    }
-
-    override async validateAsync(
-        options: IProjectValidateOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.runValidation(this._validateService, options.projectPath);
-    }
-
-    private async runValidation(
-        service: BpmnValidateService,
-        projectPath: string,
-    ): Promise<ToolResult> {
-        this.logger.info("Validating ProcessOrchestration BPMN project...");
-        const result = await service.validateProject(projectPath);
-        if (!result.isValid) {
-            if (result.message) {
-                this.logger.error(result.message);
-            }
-            return ToolResult.error(
-                result.errorCode ?? ToolErrorCodes.InternalError,
-                result.message,
-            );
-        }
-        if (result.message) {
-            this.logger.warn(result.message);
-        }
-        this.logger.info("ProcessOrchestration BPMN validation completed");
-        return ToolResult.success();
-    }
-
-    override async buildAsync(
-        options: IProjectBuildOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        const tempFolder = await this._temporaryStorage.getTempFolderPath();
-        const localBuildFolder = Path.join(
-            tempFolder,
-            NugetConstants.OutputFolderName,
-        );
-        const contentFolder = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-        );
-
-        try {
-            if (!options.skipValidate) {
-                // Error severity here: the build/pack path fails fast on an
-                // extension type absent from the contract, unlike standalone
-                // `validate`.
-                const validationResult = await this.runValidation(
-                    this._packValidateService,
-                    options.projectPath,
-                );
-                if (!validationResult.isSuccess) {
-                    return validationResult;
-                }
-            }
-
-            this.logger.progress("Copying files...");
-            await this.copyFiles(options.projectPath, contentFolder);
-
-            // Before operate.json: `ensureContentOperateFile` derives `main`
-            // from entry-points.json, so a project that shipped without one
-            // used to get `main: ""`.
-            this.logger.progress(
-                "Deriving packaging artifacts from the BPMN model...",
-            );
-            const artifactResult = await this.generateBpmnPackagingArtifacts(
-                contentFolder,
-                options,
-            );
-            if (artifactResult) {
-                return artifactResult;
-            }
-
-            this.logger.progress("Creating operate.json file...");
-            await this.createOperateFile(options, contentFolder);
-
-            this.logger.progress("Creating package-descriptor.json file...");
-            await this.createPackageDescriptor(localBuildFolder, contentFolder);
-
-            return new ToolResult(ToolErrorCodes.Success, "done", [
-                localBuildFolder,
-            ]);
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error ? error.toString() : String(error);
-            this.logger.error(errorMessage);
-            return ToolResult.error(
-                ToolErrorCodes.InternalError,
-                "An error occurred while building ProcessOrchestration project files",
-            );
-        }
-    }
-
-    override async packAsync(
-        options: IProjectPackOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        // First, run the build step to prepare the bundle content
-        const buildResult = await this.buildAsync(options, cancellationToken);
-        if (!buildResult.isSuccess) {
-            return buildResult;
-        }
-
-        const localBuildFolder = buildResult.packages[0];
-
-        try {
-            // Create the NuGet package
-            this.logger.progress("Creating NuGet package...");
-
-            const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-            const nupkgPath = Path.join(options.outputPath, nupkgFileName);
-
-            const packager = new NugetPackager(this.fileSystem);
-            const result = await packager.packAsync(
-                localBuildFolder,
-                options.package,
-                nupkgPath,
-            );
-
-            this.logger.progress("Package created successfully");
-            return new ToolResult(ToolErrorCodes.Success, "done", [
-                result.outputPath,
-            ]);
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error ? error.toString() : String(error);
-            this.logger.error(errorMessage);
-            return ToolResult.error(
-                ToolErrorCodes.InternalError,
-                "An error occurred while packing ProcessOrchestration project",
-            );
-        }
-    }
-
-    override async dispose(): Promise<void> {
-        this.logger.info("Disposing ProcessOrchestration Tool");
-        try {
-            await this._temporaryStorage.cleanup();
-        } catch {
-            // Ignore errors during cleanup
-        }
-    }
-
-    /**
-     * Copy all files from source path to content folder
-     */
-    private async copyFiles(
-        sourcePath: string,
-        destinationPath: string,
-    ): Promise<void> {
-        await this.fileSystem.mkdir(destinationPath);
-
-        const files = await this.fileSystem.readdir(sourcePath);
-
-        for (const file of files) {
-            const sourceFile = Path.join(sourcePath, file);
-            const destinationFile = Path.join(destinationPath, file);
-
-            const stat = await this.fileSystem.stat(sourceFile);
-            if (stat?.isFile()) {
-                const content = await this.fileSystem.readFile(sourceFile);
-                if (content) {
-                    await this.fileSystem.writeFile(destinationFile, content);
-                }
-            }
-        }
-    }
-
-    /**
-     * Regenerate `entry-points.json` and `bindings_v2.json` in the staging
-     * content folder from the BPMN model.
-     *
-     * `package-descriptor.json` declares both files unconditionally, but they
-     * only reached the package if the project source already carried them —
-     * which depends on who authored it. A Studio Web `.uis` export omits both
-     * for ProcessOrchestration, so those packages were rejected by the Solution
-     * Feed every time (`1203`, or `1205` for the missing entry point) while
-     * `uip solution pack` still reported success (cli#3299).
-     *
-     * Regenerating unconditionally — rather than only filling gaps — matches
-     * `packager-tool-flow` and `uip maestro refresh`, and is safe here because
-     * entry-point identity is read from the BPMN and never minted:
-     * `<bpmn:startEvent id>` supplies the filePath fragment and
-     * `<uipath:entryPointId value>` the `uniqueId`. So a stale copy on disk
-     * cannot ship, and repacking the same source is idempotent. Author-owned
-     * detail survives: `buildBpmnPackageMetadata` merges existing JSON-schema
-     * annotations, and `buildConnectionResources` preserves resource entries it
-     * does not manage.
-     *
-     * Writes into `contentFolder` (the staging copy), never back into the
-     * user's project.
-     *
-     * Additive by design: when the model yields no entry point the project's own
-     * artifacts are left exactly as they were. `validateAsync` accepts a
-     * `<bpmn:startEvent>` without a `uipath:entryPointId` (a subprocess-only or
-     * event-triggered process is a legitimate shape), so deriving is an
-     * improvement where it is possible rather than a new gate — failing here
-     * would reject projects that pack today on something validation permits.
-     * Declining to derive is not the same as fabricating: an entry-point id is
-     * never minted, because a wrong one deploys clean and faults at run time.
-     */
-    private async generateBpmnPackagingArtifacts(
-        contentFolder: string,
-        options: IProjectBuildOptions,
-    ): Promise<ToolResult | undefined> {
-        const reason = await this.deriveBpmnArtifacts(contentFolder, options);
-        if (!reason) {
-            return undefined;
-        }
-
-        // Could not derive. A package missing either artifact is rejected by the
-        // Solution Feed every time — 1203 for unreadable bindings, 1205 for no
-        // entry point — so producing one only defers a guaranteed failure to
-        // publish time. Fail here instead, with the real cause.
-        //
-        // But only when they are genuinely absent: a project may legitimately
-        // carry artifacts this packager cannot re-derive (authored by Studio
-        // Web, or a model shape the derivation does not cover). Those publish
-        // fine today, so they are passed through untouched rather than rejected.
-        const missing: string[] = [];
-        for (const name of [
-            BpmnConstants.EntryPointsFileName,
-            BpmnConstants.BindingsV2FileName,
-        ]) {
-            if (
-                !(await this.fileSystem.exists(Path.join(contentFolder, name)))
-            ) {
-                missing.push(name);
-            }
-        }
-
-        if (missing.length === 0) {
-            this.logger.warn(
-                `Could not derive the packaging artifacts, keeping the project's own: ${reason}`,
-            );
-            return undefined;
-        }
-
-        const message =
-            `Cannot produce ${missing.join(" and ")} for this ProcessOrchestration project, ` +
-            `and the project does not provide ${missing.length === 1 ? "it" : "them"}: ${reason} ` +
-            `The Solution Feed rejects a package without these files, so packing would produce ` +
-            `something that cannot be published.`;
-        this.logger.error(message);
-        return ToolResult.error(ToolErrorCodes.InternalError, message);
-    }
-
-    /**
-     * Derive and write the artifacts. Returns `undefined` on success, or a
-     * human-readable reason why derivation was not possible — the caller decides
-     * whether that is fatal.
-     */
-    private async deriveBpmnArtifacts(
-        contentFolder: string,
-        options: IProjectBuildOptions,
-    ): Promise<string | undefined> {
-        const selected = await this.selectBpmnFile(contentFolder);
-        if (selected.file === undefined) {
-            return selected.reason;
-        }
-        const bpmnFile = selected.file;
-
-        const raw = await this.fileSystem.readFile(
-            Path.join(contentFolder, bpmnFile),
-        );
-        // `raw.length` matters: read without an encoding, `readFile` returns
-        // null only on ENOENT, so a zero-byte file arrives as an empty — but
-        // truthy — Uint8Array. A truthiness-only guard would let it fall through
-        // to the parser and surface as a generic parse failure instead.
-        if (!raw || raw.length === 0) {
-            return `${bpmnFile} is empty.`;
-        }
-        const xml =
-            typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-
-        // Deferred, not a top-level import: the derivation carries bpmn-moddle,
-        // and a static import lands it in a chunk that `maestro-tool`'s eager
-        // startup graph also touches — it is only needed when a BPMN project is
-        // actually built. The BPMN validate service and refresh command defer
-        // their own heavy code for the same reason.
-        const {
-            buildBpmnPackageMetadata,
-            buildConnectionResources,
-            deriveBpmnEntryPoints,
-            formatBpmnPackageFile,
-            isJsonObject,
-            parseBpmnProcesses,
-            parseOptionalJson,
-        } = await import("@uipath/maestro-sdk/bpmn-packaging");
-
-        let processes: Awaited<ReturnType<typeof parseBpmnProcesses>>;
-        let entryPoints: ReturnType<typeof deriveBpmnEntryPoints>;
-        try {
-            processes = await parseBpmnProcesses(xml);
-            entryPoints = deriveBpmnEntryPoints(processes);
-        } catch (error) {
-            const message =
-                error instanceof Error ? error.message : String(error);
-            return `${bpmnFile} does not yield an entry point — ${message}`;
-        }
-
-        const existing = await this.readExistingArtifacts(
-            contentFolder,
-            parseOptionalJson,
-        );
-        const existingBindings = existing["bindings_v2.json"];
-        const existingResources = Array.isArray(existingBindings?.resources)
-            ? existingBindings.resources.filter(isJsonObject)
-            : [];
-
-        // buildConnectionResources throws when an Integration Service node's
-        // connection binding cannot be resolved (missing, literal, or malformed).
-        // Turn that into a specific reason here so `uip solution pack` reports
-        // the real cause instead of buildAsync's generic InternalError.
-        let resources: ReturnType<typeof buildConnectionResources>;
-        try {
-            resources = buildConnectionResources(processes, existingResources);
-        } catch (error) {
-            const message =
-                error instanceof Error ? error.message : String(error);
-            return `${bpmnFile} has an Integration Service connection binding that cannot be resolved — ${message}`;
-        }
-
-        const metadata = buildBpmnPackageMetadata({
-            bpmnFile,
-            entryPoints,
-            // Only entry-points.json and bindings_v2.json are consumed below,
-            // so this id is inert: operate.json stays owned by
-            // `ensureContentOperateFile`, which backfills the stable project id.
-            projectId: options.projectStorageId ?? crypto.randomUUID(),
-            resources,
-            existing,
-        });
-
-        // Deliberately NOT package-descriptor.json: the shared serializer emits
-        // flat paths for the project directory, while a package needs the
-        // `content/`-prefixed form that `createPackageDescriptor` writes.
-        for (const name of [
-            "entry-points.json",
-            "bindings_v2.json",
-        ] as const satisfies readonly BpmnPackageFile[]) {
-            await this.fileSystem.writeFile(
-                Path.join(contentFolder, name),
-                formatBpmnPackageFile(metadata[name]),
-            );
-        }
-
-        return undefined;
-    }
-
-    /**
-     * Decide which BPMN model the artifacts are derived from.
-     *
-     * `project.uiproj` declares the answer in `MainFile`, so it decides. A
-     * directory listing must not: `readdir` order is filesystem-dependent, and
-     * a project may legitimately hold several models — a called subprocess, or a
-     * second process kept alongside the main one. Deriving from the wrong one
-     * mints entry points for a process nobody invokes, which publishes cleanly
-     * and then faults at run time, so an ambiguous project is declined instead
-     * of guessed.
-     *
-     * `MainFile` is absent from hand-authored and older projects, so a lone
-     * `.bpmn` file still resolves without it — that is unambiguous by itself.
-     *
-     * Returns the file name, or the reason no single model could be identified.
-     */
-    private async selectBpmnFile(
-        contentFolder: string,
-    ): Promise<
-        | { file: string; reason?: undefined }
-        | { file?: undefined; reason: string }
-    > {
-        const entries = await this.fileSystem.readdir(contentFolder);
-        // Sorted so both the choice below and the reason reported to the user
-        // are stable across platforms.
-        const bpmnFiles = entries
-            .filter((entry) => entry.endsWith(".bpmn"))
-            .sort((left, right) => left.localeCompare(right));
-        if (bpmnFiles.length === 0) {
-            return { reason: "the project contains no .bpmn file." };
-        }
-
-        const mainFile = await this.readMainFile(contentFolder);
-        if (mainFile !== undefined) {
-            if (bpmnFiles.includes(mainFile)) {
-                return { file: mainFile };
-            }
-            return {
-                reason:
-                    `project.uiproj declares "MainFile": "${mainFile}", which is not one of ` +
-                    `the project's BPMN models (${bpmnFiles.join(", ")}).`,
-            };
-        }
-
-        const [onlyFile] = bpmnFiles;
-        if (bpmnFiles.length === 1 && onlyFile !== undefined) {
-            return { file: onlyFile };
-        }
-
-        return {
-            reason:
-                `the project contains ${bpmnFiles.length} BPMN models ` +
-                `(${bpmnFiles.join(", ")}) and project.uiproj does not declare which one is ` +
-                `the main model in "MainFile".`,
-        };
-    }
-
-    /**
-     * `MainFile` from the staged `project.uiproj`, or `undefined` when the
-     * project does not declare one.
-     */
-    private async readMainFile(
-        contentFolder: string,
-    ): Promise<string | undefined> {
-        let project: UiProject | undefined;
-        try {
-            project = await this.getUiProjectAsync(contentFolder);
-        } catch (error) {
-            // A malformed project.uiproj is `validateAsync`'s to report, and it
-            // has already run unless the caller passed --skip-validate. Fall
-            // back to the single-model rule rather than failing the build here
-            // on a second, less specific diagnosis of the same file.
-            this.logger.warn(
-                `Could not read project.uiproj to identify the main BPMN model: ${
-                    error instanceof Error ? error.message : String(error)
-                }`,
-            );
-            return undefined;
-        }
-
-        // `UiProject` types MainFile as a required string, but the file is
-        // user-authored and older ones omit it — so the value is checked, not
-        // trusted.
-        const mainFile: unknown = project?.MainFile;
-        return typeof mainFile === "string" && mainFile.length > 0
-            ? mainFile
-            : undefined;
-    }
-
-    /**
-     * Read the artifacts already staged in content/, so regeneration can carry
-     * forward author-owned detail. Absent or unparseable files are treated as
-     * absent — the model is the source of truth.
-     */
-    private async readExistingArtifacts(
-        contentFolder: string,
-        parseOptionalJson: (
-            raw: string | null,
-            label: string,
-        ) => JsonObject | null,
-    ): Promise<Partial<Record<BpmnPackageFile, JsonObject | null>>> {
-        const existing: Partial<Record<BpmnPackageFile, JsonObject | null>> =
-            {};
-        for (const name of [
-            "entry-points.json",
-            "bindings_v2.json",
-        ] as const satisfies readonly BpmnPackageFile[]) {
-            const raw = await this.fileSystem.readFile(
-                Path.join(contentFolder, name),
-            );
-            if (!raw) {
-                existing[name] = null;
-                continue;
-            }
-            const text =
-                typeof raw === "string" ? raw : new TextDecoder().decode(raw);
-            try {
-                existing[name] = parseOptionalJson(text, name);
-            } catch {
-                this.logger.warn(
-                    `Ignoring unparseable ${name} in the project; regenerating it from the BPMN model.`,
-                );
-                existing[name] = null;
-            }
-        }
-        return existing;
-    }
-
-    /**
-     * Create operate.json file if it doesn't already exist
-     */
-    private async createOperateFile(
-        options: IProjectBuildOptions,
-        contentFolder: string,
-    ): Promise<void> {
-        await ensureContentOperateFile(this.fileSystem, {
-            contentFolder,
-            projectPath: options.projectPath,
-            projectStorageId: options.projectStorageId,
-            contentType: ProjectTypes.ProcessOrchestration,
-        });
-    }
-
-    /**
-     * Create package-descriptor.json file.
-     * Lists standard packaging files and .bpmn files from content/.
-     */
-    private async createPackageDescriptor(
-        localBuildFolder: string,
-        contentFolder: string,
-    ): Promise<void> {
-        const descriptorFiles: Record<string, string> = {};
-
-        // Standard packaging files
-        descriptorFiles[NugetConstants.OperateFileName] = Path.join(
-            NugetConstants.ContentFolderName,
-            NugetConstants.OperateFileName,
-        );
-        descriptorFiles[BpmnConstants.EntryPointsFileName] = Path.join(
-            NugetConstants.ContentFolderName,
-            BpmnConstants.EntryPointsFileName,
-        );
-        descriptorFiles[NugetConstants.BindingsFileId] = Path.join(
-            NugetConstants.ContentFolderName,
-            BpmnConstants.BindingsV2FileName,
-        );
-
-        // Add .bpmn files from content/
-        const contentFiles = await this.fileSystem.readdir(contentFolder);
-        for (const file of contentFiles) {
-            if (file.endsWith(".bpmn")) {
-                descriptorFiles[file] = Path.join(
-                    NugetConstants.ContentFolderName,
-                    file,
-                );
-            }
-        }
-
-        const packageDescriptorPath = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-            NugetConstants.PackageDescriptorFileName,
-        );
-        const packageDescriptorJson = JSON.stringify(
-            {
-                $schema:
-                    "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-                files: descriptorFiles,
-            },
-            null,
-            2,
-        );
-        await this.fileSystem.writeFile(
-            packageDescriptorPath,
-            packageDescriptorJson,
-        );
-    }
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-// BPMN (ProcessOrchestration) tool factory.
-//
-// Self-registers on import so micro-frontend consumers (whose MFEs UiPath does
-// not control) that load this package via a side-effect import get the factory
-// registered automatically — StudioWeb does not reference this package, so it
-// relies on self-registration. Also exported for consumers that register
-// explicitly; re-registering the same factory class is an idempotent no-op.
-import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
-import { BpmnToolFactory } from "./bpmn-tool-factory.js";
-
-toolsFactoryRepository.registerProjectToolFactory(new BpmnToolFactory());
-
-export { BpmnToolFactory };