@uipath/maestro-sdk 1.198.0 → 1.199.0-preview.104

package/dist/src/bpmn-validation/canvas/canvas-validator.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Offline canvas validator for UiPath Maestro BPMN XML.
+ *
+ * Pipeline (mirrors the Studio Web import + canvas validation path):
+ *   1. Strict XML well-formedness gate via sax. bpmn-moddle's SAX parser
+ *      (saxen) is lenient: it accepts unescaped `&`/`<`, `--` inside comments,
+ *      and other malformed input that strict parsers — and the Studio Web
+ *      canvas import — reject. A validator that is more permissive than the
+ *      real import gives false confidence, so parse strictly first and refuse
+ *      anything the import would refuse.
+ *   2. Parse the BPMN with bpmn-moddle using the UiPath extension descriptor
+ *      (same getModdle() + fromXML() pattern as PO.Frontend).
+ *   3. Reconstruct the PO.Frontend Node[]/Edge[]/CanvasState model (`model.ts`).
+ *   4. Run the PO.Frontend validation rules (`rules.ts`) per diagram, plus
+ *      the whole-model variable-existence and variable-not-set checks.
+ *
+ * Fully offline: no tenant calls, no filesystem access — callers pass the XML
+ * string.
+ */
+import type { CanvasFinding } from "./types";
+export interface CanvasValidationResult {
+    /** All rule findings (ERROR + WARNING severities). */
+    findings: CanvasFinding[];
+    /** Non-blocking bpmn-moddle parse warnings. */
+    parseWarnings: string[];
+}
+/** Finding code for input the strict XML parser rejects. */
+export declare const XML_NOT_WELL_FORMED = "XML_NOT_WELL_FORMED";
+/** Finding code for input bpmn-moddle cannot parse as BPMN. */
+export declare const BPMN_PARSE_ERROR = "BPMN_PARSE_ERROR";
+/**
+ * Validate a Maestro BPMN document against the full PO.Frontend canvas rule
+ * set. Parse failures are returned as ERROR findings (`XML_NOT_WELL_FORMED` /
+ * `BPMN_PARSE_ERROR`) rather than thrown, so callers can treat every outcome
+ * uniformly.
+ */
+export declare function validateBpmnCanvas(xml: string): Promise<CanvasValidationResult>;

package/dist/src/bpmn-validation/canvas/model.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Reconstruct the PO.Frontend Node[]/Edge[]/CanvasState model from a parsed
+ * bpmn-moddle tree. This is the integration layer between BPMN XML and the
+ * ported rule engine in `rules.ts`. It mirrors
+ * PO.Frontend/src/services/serialization/bpmn-from-xml.ts closely enough that
+ * the rules see the same fields they see on canvas.
+ *
+ * Required-field metadata for the RequiredFields rule comes from the SDK's own
+ * static spec (`manifest/bpmn-spec.json`) — the same PO.Frontend-extracted
+ * catalog the registry commands use — so there is a single spec snapshot in
+ * the CLI.
+ */
+import type { CanvasEdge, CanvasNode, CanvasState } from "./types";
+interface ModdleTypeAttr {
+    value?: string;
+    version?: string;
+}
+interface ModdleUiPathField {
+    name?: string;
+    displayName?: string;
+    type?: string;
+    subType?: string;
+    value?: unknown;
+    target?: string;
+    body?: unknown;
+    source?: unknown;
+    var?: string;
+    custom?: unknown;
+    required?: unknown;
+    originalVar?: string;
+}
+interface ModdleUiPathActivity {
+    $type?: string;
+    type?: ModdleTypeAttr | string;
+    version?: string;
+    context?: {
+        input?: ModdleUiPathField[];
+    };
+    input?: ModdleUiPathField[];
+    output?: ModdleUiPathField[];
+}
+interface ModdleUiPathError {
+    id?: string;
+    errorRef?: string;
+    priority?: unknown;
+    condition?: string;
+    detail?: unknown;
+    retryable?: unknown;
+}
+interface ModdleUiPathVariable {
+    id?: string;
+    name?: string;
+    type?: string;
+    subType?: string;
+    canonicalId?: string;
+    elementId?: string;
+    default?: unknown;
+}
+interface ModdleExtensionElement extends ModdleUiPathActivity {
+    error?: ModdleUiPathError[];
+    input?: ModdleUiPathField[] & ModdleUiPathVariable[];
+    inputOutput?: ModdleUiPathVariable[];
+    output?: ModdleUiPathField[] & ModdleUiPathVariable[];
+}
+interface ModdleEventDefinition {
+    $type: string;
+    id?: string;
+    errorRef?: ModdleElement | string;
+    messageRef?: ModdleElement | string;
+    signalRef?: ModdleElement | string;
+    escalationRef?: ModdleElement | string;
+    timeDuration?: {
+        body?: string;
+    } | string;
+    timeCycle?: {
+        body?: string;
+    } | string;
+    timeDate?: {
+        body?: string;
+    } | string;
+}
+export interface ModdleElement {
+    $type: string;
+    id?: string;
+    name?: string;
+    rootElements?: ModdleElement[];
+    flowElements?: ModdleElement[];
+    participants?: ModdleElement[];
+    messageFlows?: ModdleElement[];
+    processRef?: ModdleElement | string;
+    eventDefinitions?: ModdleEventDefinition[];
+    triggeredByEvent?: boolean;
+    attachedToRef?: ModdleElement | string;
+    sourceRef?: ModdleElement | string;
+    targetRef?: ModdleElement | string;
+    conditionExpression?: {
+        body?: string;
+    } | string;
+    default?: ModdleElement | string;
+    extensionElements?: {
+        values?: ModdleExtensionElement[];
+    };
+    errorCode?: string;
+    escalationCode?: string;
+}
+export declare function buildModel(definitionsElement: unknown): CanvasState;
+export declare function collectKnownVariableIds(canvasState: CanvasState): Set<string>;
+export declare function allNodes(canvasState: CanvasState): CanvasNode[];
+export declare function allEdges(canvasState: CanvasState): CanvasEdge[];
+export {};

package/dist/src/bpmn-validation/canvas/rules.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Self-contained Maestro BPMN canvas validation rule engine.
+ *
+ * This module is a faithful, offline port of the PO.Frontend canvas validation
+ * rule engine (PO.Frontend/src/services/validation/bpmn/). It operates on the
+ * reconstructed Node[]/Edge[]/CanvasState model (see `model.ts`), which mirrors
+ * the frontend's `Node[]`/`Edge[]` derived from the same BPMN XML.
+ *
+ * Each rule cites the PO.Frontend source it is ported from. Where the port
+ * intentionally matches an observable frontend quirk instead of the literal
+ * rule text, the divergence is documented inline (see FakeJoinRule).
+ */
+import type { CanvasDiagram, CanvasEdge, CanvasFinding, CanvasNode, CanvasState, ValidateDiagramOptions, ValidateVariableNotSetOptions, ValidationLookupMaps } from "./types";
+import { SEVERITY } from "./types";
+export { SEVERITY };
+export declare function buildValidationLookupMaps(nodes: CanvasNode[], edges: CanvasEdge[]): ValidationLookupMaps;
+/**
+ * Port of VariableUtil.validateNoAssignments. Returns true if the expression
+ * contains an assignment operator (excluding comparison/arrow operators).
+ */
+export declare function expressionHasAssignment(expression: string | undefined): boolean;
+/**
+ * Collect every `vars.X` / `result.X` reference in an expression that does NOT
+ * resolve. Mirrors VariableUtil.getVariablesInExpression (the `nonExisting`
+ * half) + the result-validity split in validateVariablesInExpression:758-782.
+ *
+ *  - `vars.X` resolves against `knownIds` (variable ids/names/canonicalIds,
+ *    declared anywhere) — matches `existingIdsSet` semantics in the frontend.
+ *  - `result.X` resolves ONLY against the referencing element's OWN output
+ *    identifiers (`resultIds`); a `result.X` that names no output of this
+ *    element is flagged, exactly like `isResultVariableValidForElement`
+ *    (VariableUtil.ts:166-178) pushing it onto the non-existing set
+ *    (VariableUtil.ts:263 treats the unresolved result ref as non-existing).
+ *
+ * `resultIds` defaults to an empty set: in contexts where result refs are not
+ * element-local (e.g. edge conditions, which have no own outputs) every
+ * `result.X` is unresolved, matching the frontend.
+ */
+export declare function findUnknownVariableRefs(expression: string | undefined, knownIds: Set<string>, resultIds?: Set<string>): string[];
+export declare function validateConditionalSequenceFlow(nodes: CanvasNode[], _edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateConnections(_nodes: CanvasNode[], edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateDuplicateErrorEventSubprocess(nodes: CanvasNode[], canvasState: CanvasState, lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateEventSubProcessStart(nodes: CanvasNode[], _edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateErrorBoundaryEvents(nodes: CanvasNode[]): CanvasFinding[];
+export declare function validateDuplicateErrorBoundaryEvents(nodes: CanvasNode[], canvasState: CanvasState): CanvasFinding[];
+export declare function validateErrorEndEvents(nodes: CanvasNode[]): CanvasFinding[];
+export declare function validateFakeJoins(nodes: CanvasNode[] | undefined, edges: CanvasEdge[] | undefined, lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateMessageFlowCrossPool(nodes: CanvasNode[], edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateMissingResource(nodes: CanvasNode[]): CanvasFinding[];
+export declare function validateMissingRootVariables(nodes: CanvasNode[], canvasState: CanvasState): CanvasFinding[];
+export declare function validateNoAssignmentsInExpressions(nodes: CanvasNode[] | undefined, edges: CanvasEdge[] | undefined): CanvasFinding[];
+export declare function validateRequiredFields(nodes: CanvasNode[] | undefined): CanvasFinding[];
+export declare function validateSequenceFlowPoolCrossing(nodes: CanvasNode[], edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateSequenceFlowSubProcessCrossing(_nodes: CanvasNode[], edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateSingleBlankStartEvent(nodes: CanvasNode[] | undefined, edges: CanvasEdge[] | undefined, lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateSingleStartEventInEventSubProcess(nodes: CanvasNode[], _edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateSuperfluousGateway(nodes: CanvasNode[] | undefined, edges: CanvasEdge[] | undefined, lookupMaps: ValidationLookupMaps): CanvasFinding[];
+export declare function validateTaskTimerRange(nodes: CanvasNode[] | undefined): CanvasFinding[];
+export declare function validateTimerDuration(nodes: CanvasNode[] | undefined): CanvasFinding[];
+/**
+ * Flags nodes whose only outgoing sequence flow carries a condition
+ * expression. At runtime the flow is taken only when the condition evaluates
+ * to true, so a false condition leaves the token with no path forward and the
+ * instance silently stops progressing past the node.
+ */
+export declare function validateSingleConditionalOutgoingFlow(nodes: CanvasNode[], _edges: CanvasEdge[], lookupMaps: ValidationLookupMaps): CanvasFinding[];
+/**
+ * Validates that timer events have required fields populated based on their
+ * timerType: timeDate requires timeDate, timeDuration requires timeDuration,
+ * timeCycle requires timeCycle.
+ */
+export declare function validateTimerRequiredFields(nodes: CanvasNode[] | undefined): CanvasFinding[];
+export declare function validateEventObjectFields(canvasState: CanvasState): CanvasFinding[];
+export declare function validateMethodParentheses(allNodesList: CanvasNode[], allEdgesList: CanvasEdge[]): CanvasFinding[];
+/**
+ * Literal type mismatches on agent-job inputs are surfaced as warnings, not
+ * errors: a value like a stringified JSON object is still a valid literal for
+ * some targets, so the likely mistake is flagged without blocking.
+ */
+export declare function validateInputTypeMismatch(allNodesList: CanvasNode[]): CanvasFinding[];
+export declare function validateVariableExistence(allNodesList: CanvasNode[], allEdgesList: CanvasEdge[], knownIds: Set<string>): CanvasFinding[];
+export declare function validateVariableNotSet(allNodesList: CanvasNode[], allEdgesList: CanvasEdge[], knownIds: Set<string>, canvasState: CanvasState | undefined, options?: ValidateVariableNotSetOptions): CanvasFinding[];
+export declare function validateDiagram(diagram: CanvasDiagram, canvasState: CanvasState, options?: ValidateDiagramOptions): CanvasFinding[];
+export declare const RULE_CODES: readonly ["MISSING_CONDITION_EXPRESSION", "INVALID_CONNECTION", "INVALID_CONNECTION_TYPE", "DUPLICATE_ERROR_EVENT_SUBPROCESS", "MULTIPLE_CATCH_ALL_ERROR_EVENT_SUBPROCESS", "START_EVENT_WITHOUT_DEFINITION_IN_EVENT_SUBPROCESS", "INVALID_EVENT_DEFINITION_IN_EVENT_SUBPROCESS", "START_EVENT_WITH_DEFINITION_IN_SUBPROCESS", "ERROR_BOUNDARY_EVENT_EMPTY_ERROR_REF", "MULTIPLE_CATCH_ALL_BOUNDARY_EVENTS_ON_TASK", "DUPLICATE_ERROR_BOUNDARY_EVENT_ON_TASK", "ERROR_END_EVENT_MISSING_EXCEPTION", "FAKE_JOIN", "SAME_POOL_MESSAGE_FLOW", "MISSING_RESOURCE", "MISSING_ROOT_VARIABLE", "ASSIGNMENT_NOT_ALLOWED", "EMPTY_REQUIRED_FIELD", "CROSSING_POOL_BOUNDARY", "CROSSING_SUBPROCESS_BOUNDARY", "MULTIPLE_BLANK_START_EVENTS", "MULTIPLE_START_EVENTS_IN_EVENT_SUBPROCESS", "SUPERFLUOUS_GATEWAY", "TASK_TIMER_OUT_OF_RANGE", "TIMER_DURATION_INVALID", "TIMER_DURATION_WEEK_UNSUPPORTED", "VARIABLE_DOES_NOT_EXIST", "VARIABLE_NOT_SET", "SINGLE_CONDITIONAL_OUTGOING_FLOW", "TIMER_MISSING_REQUIRED_FIELD", "EVENT_OBJECT_EMPTY_REQUIRED_FIELD", "EVENT_OBJECT_DUPLICATE_FIELD", "METHOD_MISSING_PARENTHESES", "INPUT_TYPE_MISMATCH"];

package/dist/src/bpmn-validation/canvas/test-helpers.d.ts

@@ -0,0 +1,16 @@
+import type { CanvasEdge, CanvasEdgeData, CanvasErrorObject, CanvasNamedObject, CanvasNode, CanvasNodeData, CanvasState, UiPathVariableGroups, ValidationLookupMaps } from "./types";
+export declare function node(id: string, type: string, data?: CanvasNodeData, extra?: Partial<Pick<CanvasNode, "parentId" | "abstractType">>): CanvasNode;
+export declare function edge(id: string, source: string, target: string, { type, data, }?: {
+    type?: string;
+    data?: CanvasEdgeData;
+}): CanvasEdge;
+export declare function canvasState({ errors, signals, messages, escalations, rootVariables, diagramNodes, diagramEdges, }?: {
+    errors?: CanvasErrorObject[];
+    signals?: CanvasNamedObject[];
+    messages?: CanvasNamedObject[];
+    escalations?: CanvasNamedObject[];
+    rootVariables?: UiPathVariableGroups;
+    diagramNodes?: CanvasNode[];
+    diagramEdges?: CanvasEdge[];
+}): CanvasState;
+export declare function maps(nodes?: CanvasNode[], edges?: CanvasEdge[]): ValidationLookupMaps;

package/dist/src/bpmn-validation/canvas/types.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Types for the canvas validation rule engine — a faithful, offline port of
+ * the PO.Frontend canvas validation rules (PO.Frontend/src/services/validation/bpmn/).
+ *
+ * `CanvasNode` / `CanvasEdge` / `CanvasState` mirror the frontend `Node[]` /
+ * `Edge[]` / `CanvasState` model that the frontend derives from BPMN XML, so
+ * the ported rules in `rules.ts` see the same fields they see on canvas.
+ */
+export declare const SEVERITY: {
+    readonly ERROR: "ERROR";
+    readonly WARNING: "WARNING";
+};
+export type CanvasSeverity = (typeof SEVERITY)[keyof typeof SEVERITY];
+export interface CanvasFinding {
+    code: string;
+    message: string;
+    severity: CanvasSeverity;
+    elementId?: string;
+    sourceId?: string;
+    targetId?: string;
+}
+export interface UiPathField {
+    name?: string;
+    displayName?: string;
+    type?: string;
+    subType?: string;
+    value?: unknown;
+    target?: string;
+    body?: unknown;
+    required?: boolean;
+}
+export interface UiPathOutputField extends UiPathField {
+    source?: unknown;
+    var?: string;
+    custom?: boolean;
+    canonicalId?: string;
+    /** Original variable id before a user reassignment; serialized to XML. */
+    originalVar?: string;
+}
+export interface UiPathVariable {
+    id?: string;
+    name?: string;
+    type?: string;
+    subType?: string;
+    canonicalId?: string;
+    elementId?: string;
+    default?: unknown;
+}
+export interface UiPathVariableGroups {
+    inputs?: UiPathVariable[];
+    inputOutputs?: UiPathVariable[];
+    outputs?: UiPathVariable[];
+}
+export interface UiPathErrorMapping {
+    id?: string;
+    errorRef?: string;
+    priority?: unknown;
+    condition?: string;
+    detail?: unknown;
+    retryable?: boolean;
+}
+export interface UiPathNodeData {
+    serviceType?: string;
+    version?: string;
+    context?: UiPathField[];
+    inputs?: UiPathField[];
+    outputs?: UiPathOutputField[];
+    errorMapping?: UiPathErrorMapping[];
+    variables?: UiPathVariableGroups;
+    requiredFieldNames?: string[];
+}
+export interface CanvasEventDefinition {
+    type?: string;
+    id?: string;
+    errorRef?: string;
+    messageRef?: string;
+    signalRef?: string;
+    escalationRef?: string;
+    timerType?: "timeDuration" | "timeCycle" | "timeDate";
+    timeDuration?: string;
+    timeCycle?: string;
+    timeDate?: string;
+}
+export interface CanvasParentRef {
+    id: string;
+    type: string;
+}
+export interface CanvasNodeData {
+    label?: string;
+    eventDefinition?: CanvasEventDefinition;
+    triggeredByEvent?: boolean;
+    attachedToId?: string;
+    uipath?: UiPathNodeData;
+    parentElement?: CanvasParentRef;
+    processRef?: string;
+}
+export interface CanvasNode {
+    id: string;
+    type: string;
+    parentId?: string;
+    abstractType?: string;
+    data: CanvasNodeData;
+}
+export interface CanvasEdgeData {
+    label?: string;
+    conditionExpression?: string;
+    defaultFlow?: boolean;
+    parentElement?: CanvasParentRef;
+}
+export interface CanvasEdge {
+    id: string;
+    type?: string;
+    source?: string;
+    target?: string;
+    data: CanvasEdgeData;
+}
+export interface CanvasErrorObject {
+    id?: string;
+    name?: string;
+    errorCode?: string;
+}
+export interface CanvasNamedObject {
+    id?: string;
+    name?: string;
+    escalationCode?: string;
+}
+export interface CanvasObjects {
+    errors: CanvasErrorObject[];
+    messages: CanvasNamedObject[];
+    signals: CanvasNamedObject[];
+    escalations: CanvasNamedObject[];
+}
+export interface CanvasDiagram {
+    diagramId: string;
+    root: CanvasParentRef;
+    nodes: CanvasNode[];
+    edges: CanvasEdge[];
+}
+export interface CanvasState {
+    rootDiagramId?: string;
+    root: CanvasNode;
+    diagramsById: Record<string, CanvasDiagram>;
+    objects?: CanvasObjects;
+}
+export interface ValidationLookupMaps {
+    nodeById: Map<string, CanvasNode>;
+    nodesByParentId: Map<string | undefined, CanvasNode[]>;
+    edgesBySource: Map<string | undefined, CanvasEdge[]>;
+    edgesByTarget: Map<string | undefined, CanvasEdge[]>;
+}
+export interface ValidateDiagramOptions {
+    enableMissingRootVariableValidation?: boolean;
+}
+export interface ValidateVariableNotSetOptions {
+    isCaseManagement?: boolean;
+}

package/dist/src/debug-http-client.d.ts

@@ -6,7 +6,7 @@
 import type { OrchestratorApiConfig } from "./debug-types";
 /** Logical service the helper is talking to. Used by callers / formatters
  *  to render the failing endpoint with the right URL prefix. */
-export type DebugApiService = "orchestrator" | "pims" | "studio-web";
+export type DebugApiService = "automation-solutions" | "orchestrator" | "pims" | "studio-web";
 /** Structured payload carried by a {@link MaestroHttpError}. Every field
  *  except {@link stage} is always populated; {@link stage} is filled in by the
  *  caller via the optional `stage` parameter on each helper. */
@@ -83,6 +83,8 @@ export declare class MaestroHttpError extends Error {
      *  `FailureOutput.Context`. */
     private static formatMessage;
 }
+/** Make a GET request to the Automation Solutions API. */
+export declare function automationSolutionsGet<T>(config: OrchestratorApiConfig, path: string, stage?: string, signal?: AbortSignal): Promise<T>;
 /**
  * Make a GET request to Orchestrator API.
  * @param stage Optional pipeline stage label (e.g. "get-personal-folder").

package/dist/src/debug-service.d.ts

@@ -74,18 +74,19 @@ export interface PrepareForCustomDebugParams {
     solutionName: string;
     folderKey: string;
     sessionId?: string;
+    provisioningTimeoutMs?: number;
+    provisioningPollIntervalMs?: number;
 }
 export interface PrepareForCustomDebugResponse {
     solutionDebugId: string;
     projectDebugId: string;
 }
 /**
- * Prepare Studio Web debug IDs for a local workspace project.
+ * Prepare a local workspace project for Studio Web debug.
  *
- * This mirrors Studio Web's injected Debug service
- * `prepareForCustomDebug(projectId)`: it asks Studio Web Resource Builder to
- * provision a cloud-backed debug solution/project and returns the IDs PIMS
- * must use for execution.
+ * Studio Web loads the uploaded solution graph, starts resource provisioning,
+ * and returns immediately when no work is needed. Pending work is polled via
+ * Automation Solutions before execution starts.
  */
 export declare function prepareForCustomDebug(params: PrepareForCustomDebugParams): Promise<PrepareForCustomDebugResponse>;
 /**
@@ -228,12 +229,12 @@ export interface UploadAndDebugParams {
         name: string;
     }>, solutionId: string) => Promise<SolutionProjectDescriptor[]> | SolutionProjectDescriptor[];
     /**
-     * Solution name passed to {@link prepareForCustomDebug}. Surfaces in
-     * Studio Web's debug-solution metadata; falls back to `projectName` when
-     * omitted. Has no effect on routing — Orchestrator only cares that the
-     * resource-builder call returned the debug IDs.
+     * Solution name passed to {@link prepareForCustomDebug}. Falls back to
+     * `projectName` when omitted.
      */
     solutionName?: string;
+    /** Fail instead of falling back when Studio Web debug preparation fails. */
+    requireDebugPreparation?: boolean;
 }
 /**
  * Shared upload-and-debug lifecycle used by flow-tool, maestro-tool, and case-tool.
@@ -241,10 +242,11 @@ export interface UploadAndDebugParams {
  * 1. Uploads solution to Studio Web (via caller-provided `upload` fn)
  * 2. Persists solutionId locally (via `onSolutionId` callback)
  * 3. Fetches personal workspace folder
- * 4. Begins debug session in Orchestrator
- * 5. Creates debug instance in PIMS
- * 6. Polls for completion
- * 7. Returns DebugResult with solutionId and studioWebUrl
+ * 4. Prepares the Studio Web debug mapping and resources
+ * 5. Begins debug session in Orchestrator
+ * 6. Creates debug instance in PIMS
+ * 7. Polls for completion
+ * 8. Returns DebugResult with solutionId and studioWebUrl
  */
 export declare function uploadAndDebugSolution(params: UploadAndDebugParams): Promise<DebugResult>;
 /**

package/dist/src/debug-types.d.ts

@@ -62,6 +62,10 @@ export interface InlineAgentDescriptor {
      * resolves the path against the deployed package.
      */
     entryPointPath: string;
+    /** Name of the Flow project whose package contains this inline agent. */
+    hostProjectName?: string;
+    /** Studio Web project id resolved for {@link hostProjectName} after upload. */
+    hostProjectId?: string;
 }
 /**
  * Describes an in-solution sibling project (a flow-as-node callee, RPA

package/dist/src/index.d.ts

@@ -1,3 +1,7 @@
+export { BPMN_PARSE_ERROR, type CanvasValidationResult, validateBpmnCanvas, XML_NOT_WELL_FORMED, } from "./bpmn-validation/canvas/canvas-validator";
+export { RULE_CODES } from "./bpmn-validation/canvas/rules";
+export type { CanvasFinding, CanvasSeverity, } from "./bpmn-validation/canvas/types";
+export { SEVERITY as CANVAS_SEVERITY } from "./bpmn-validation/canvas/types";
 export type { BpmnFileValidationContext, BpmnFileValidator, BpmnProjectValidationContext, BpmnProjectValidator, BpmnValidateServiceOptions, BpmnValidationDiagnostic, BpmnValidationFileSystem, BpmnValidationResult, } from "./bpmn-validation/project-validator";
 export { BpmnValidateService } from "./bpmn-validation/project-validator";
 export { pimsGet, pimsPatch, pimsPost, pimsPut } from "./client";

package/dist/src/registry/node-storage.d.ts

@@ -1,5 +1,5 @@
 import type { NodeManifest } from "@uipath/flow-core";
-export declare const CACHE_FORMAT_VERSION = 1;
+export declare const CACHE_FORMAT_VERSION = 2;
 export interface SearchableNode {
     nodeType?: string;
     category?: string;

package/dist/src/registry/node-sync-service.d.ts

@@ -18,6 +18,7 @@ interface PullRemoteNodesResult {
     cacheable: boolean;
     info?: string;
 }
+export declare function isExcludedNodeType(nodeType: string | undefined): boolean;
 /**
  * Pull and sync all node sources with smart caching
  *

package/dist/src/registry/registry-service.d.ts

@@ -23,8 +23,8 @@ import type { BpmnExtensionType, DiscoveredConnector, DiscoveredProcess, Maestro
  *
  * This list is a deliberate SUPERSET of flow-core's
  * `ORCHESTRATOR_RESOURCE_TYPES` (`Process`, `Agent`, `ProcessOrchestration`,
- * `Flow`, `Api`, `Function`): the first six mirror the canvas/node-index
- * exactly, and `CaseManagement`/`BusinessRules` are the bindable extras the
+ * `Flow`, `CaseManagement`, `Api`, `Function`): those seven mirror the
+ * canvas/node-index exactly, and `BusinessRules` is the bindable extra the
  * canvas does not yet surface but Maestro authoring can reference.
  * orchestrator-tool's `processes list` command filters the same endpoint by
  * these same `ProcessType` values, so they are known-good filters.

package/dist/src/shared-commands/process.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 export interface ProcessCommandsConfig {
     /** Label used in command descriptions, e.g. "Flow", "Maestro", "Case" */
     toolLabel: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/maestro-sdk",
   "license": "MIT",
-  "version": "1.198.0",
+  "version": "1.199.0-preview.104",
   "description": "SDK for the UiPath Maestro (PIMS) API — process instance management.",
   "repository": {
     "type": "git",
@@ -42,5 +42,5 @@
   "files": [
     "dist"
   ],
-  "gitHead": "1fadf03d7a8dd102742571dff569fdac11808afb"
+  "gitHead": "829a8ab8a25bce5b62c284bd1ddc674d2947f647"
 }