@uipath/maestro-sdk 1.0.4 → 1.195.0

package/dist/manifest/bpmn-spec.js

@@ -57,6 +57,32 @@ var bpmn_spec_default = {
     designSchemaJsonDir: "src/services/serialization/design-schema/*.design-schema.json"
   },
   extensionTypes: {
+    "uipath:Activity": {
+      extensionType: "uipath:Activity",
+      label: "Canvas activity",
+      bpmnElement: "bpmn:ServiceTask",
+      placements: {
+        serviceTask: {
+          type: "bpmn:ServiceTask"
+        },
+        task: {
+          type: "bpmn:Task"
+        },
+        boundaryEvent: {
+          type: "bpmn:BoundaryEvent"
+        }
+      },
+      extensionTag: "uipath:activity",
+      contextFields: [],
+      inputPattern: "none",
+      outputSource: null,
+      outputType: null,
+      bindingPattern: "none",
+      requiresDiscovery: false,
+      isDynamic: true,
+      xmlTemplate: null,
+      outputNotes: "Studio Web canvas can emit custom output-only activity payloads for placeholder tasks and error boundary metadata."
+    },
     "Actions.HITL": {
       extensionType: "Actions.HITL",
       label: "Create action app task",
@@ -246,46 +272,33 @@ var bpmn_spec_default = {
       extensionTag: "uipath:activity",
       contextFields: [
         {
-          name: "releaseKey",
-          displayName: "Process",
+          name: "name",
+          displayName: "Agent",
           type: "string",
-          required: false,
+          required: true,
           hidden: true,
           isPrimaryKey: false,
-          binding: false,
+          binding: true,
           defaultValue: null,
           bindingInfo: {
             resource: "process",
             resourceKeyPattern: "${metadata.key}",
-            propertyAttribute: "Key"
+            propertyAttribute: "name"
           }
         },
-        {
-          name: "folderId",
-          type: "string",
-          required: false,
-          hidden: true,
-          isPrimaryKey: false,
-          binding: false,
-          defaultValue: null
-        },
         {
           name: "folderPath",
           type: "string",
-          required: false,
-          hidden: true,
-          isPrimaryKey: false,
-          binding: false,
-          defaultValue: null
-        },
-        {
-          name: "name",
-          type: "string",
-          required: false,
+          required: true,
           hidden: true,
           isPrimaryKey: false,
-          binding: false,
-          defaultValue: null
+          binding: true,
+          defaultValue: null,
+          bindingInfo: {
+            resource: "process",
+            resourceKeyPattern: "${metadata.key}",
+            propertyAttribute: "folderPath"
+          }
         }
       ],
       inputPattern: "mergedBody",
@@ -299,25 +312,20 @@ var bpmn_spec_default = {
       bindingInfo: {
         resource: "process",
         resourceKeyPattern: "${metadata.key}",
-        propertyAttribute: "Key",
-        contextField: "releaseKey"
+        propertyAttribute: "name",
+        contextField: "name"
       },
       requiresDiscovery: true,
       isDynamic: true,
       xmlTemplate: `<bpmn:ServiceTask id="{id}" name="{name}">
-  <bpmn:extensionElements>
-    <uipath:activity version="v1">
-      <uipath:type value="Orchestrator.StartAgentJob" version="v1" />
-      <uipath:context>
-        <uipath:input name="releaseKey" value="{releaseKey}" />
-        <uipath:input name="folderId" value="{folderId}" />
-        <uipath:input name="folderPath" value="{folderPath}" />
-        <uipath:input name="name" value="{name}" />
-      </uipath:context>
-      <uipath:input name="JobArguments" type="json" target="bodyField"><![CDATA[{}]]></uipath:input>
-      <uipath:output name="Process response" type="Orchestrator.RunJob" var="{varId}" />
-    </uipath:activity>
-  </bpmn:extensionElements>
+  <uipath:activity type="Orchestrator.StartAgentJob" version="v1">
+    <uipath:context>
+      <uipath:input name="name" value="=bindings.{nameBindingId}" />
+      <uipath:input name="folderPath" value="=bindings.{folderPathBindingId}" />
+    </uipath:context>
+    <uipath:input name="JobArguments" type="json" target="bodyField"><![CDATA[{}]]></uipath:input>
+    <uipath:output name="Process response" type="Orchestrator.RunJob" var="{varId}" />
+  </uipath:activity>
   <bpmn:incoming>{incomingEdge}</bpmn:incoming>
   <bpmn:outgoing>{outgoingEdge}</bpmn:outgoing>
 </bpmn:ServiceTask>`,
@@ -2961,10 +2969,14 @@ var STATIC_UIPATH_EXTENSION_TAG_NAMES = [
   "caseManagement",
   "context",
   "entryPointId",
+  "error",
+  "errorDefinition",
+  "errorMapping",
   "input",
   "inputOutput",
   "inputSchema",
   "intsvcActivityConfig",
+  "isTransactionRoot",
   "loopCharacteristics",
   "migrationVersion",
   "output",

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

@@ -0,0 +1,64 @@
+export interface BpmnValidationFileSystem {
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string): Promise<Uint8Array | null>;
+    exists(path: string): Promise<boolean>;
+    joinPath(...segments: string[]): string;
+}
+export interface BpmnValidationDiagnostic {
+    file: string;
+    element?: string;
+    message: string;
+    instruction: string;
+    severity?: "error" | "warning";
+}
+export interface BpmnFileValidationContext {
+    projectPath: string;
+    file: string;
+    xml: string;
+    fileSystem: BpmnValidationFileSystem;
+}
+export interface BpmnProjectValidationContext {
+    projectPath: string;
+    bpmnFiles: readonly string[];
+    fileSystem: BpmnValidationFileSystem;
+}
+export interface BpmnFileValidator {
+    name: string;
+    validate(context: BpmnFileValidationContext): BpmnValidationDiagnostic[] | Promise<BpmnValidationDiagnostic[]>;
+}
+export interface BpmnProjectValidator {
+    name: string;
+    validate(context: BpmnProjectValidationContext): BpmnValidationDiagnostic[] | Promise<BpmnValidationDiagnostic[]>;
+}
+export interface BpmnValidateServiceOptions {
+    fileValidators?: readonly BpmnFileValidator[];
+    projectValidators?: readonly BpmnProjectValidator[];
+}
+export interface BpmnValidationResult {
+    isValid: boolean;
+    errorCode?: string;
+    diagnostics: BpmnValidationDiagnostic[];
+    message?: string;
+}
+export declare class BpmnValidateService {
+    private readonly fileSystem;
+    private readonly options;
+    constructor(fileSystem: BpmnValidationFileSystem, options?: BpmnValidateServiceOptions);
+    validateProject(projectPath: string): Promise<BpmnValidationResult>;
+    private validateBpmnFile;
+    private validateUiPathTags;
+    private validatePayload;
+    private validateContractPlacement;
+    private validateContext;
+    private validateInputs;
+    private validateDynamicDirectInputs;
+    private validateVariableMappingInputs;
+    private validateOutput;
+    private validateBindingReferences;
+    private validateStartAgentJobBindings;
+    private loadBindings;
+    private runFileValidators;
+    private runProjectValidators;
+    private createFailure;
+    private createWarningMessage;
+}

package/dist/src/client.d.ts

@@ -1,4 +1,24 @@
 import type { PimsApiConfig, PimsRequestOptions } from "./types";
+export declare class PimsApiError extends Error {
+    readonly method: string;
+    readonly endpoint: string;
+    readonly url: string;
+    readonly httpStatus: number;
+    readonly statusText: string;
+    readonly body: string;
+    readonly parsedErrorMessage?: string;
+    readonly parsedErrorCode?: string;
+    readonly parsedTraceId?: string;
+    readonly parsedRequestId?: string;
+    constructor(details: {
+        method: string;
+        endpoint: string;
+        url: string;
+        httpStatus: number;
+        statusText: string;
+        body: string;
+    });
+}
 export declare function pimsGet<T>(config: PimsApiConfig, path: string, options?: PimsRequestOptions): Promise<T>;
 export declare function pimsPost<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;
 export declare function pimsPut<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;

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

@@ -3,7 +3,7 @@
  * Provides common methods used by flow-tool, case-tool, and maestro-tool.
  */
 import type { IFileSystem } from "@uipath/filesystem";
-import type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, InlineAgentDescriptor, OrchestratorApiConfig } from "./debug-types";
+import type { BeginSessionResponse, DebugCallbacks, DebugIncidentResponse, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, InlineAgentDescriptor, OrchestratorApiConfig, StudioWebDebugConfig } from "./debug-types";
 /**
  * Thrown by {@link injectInlineAgentProcessEntries} when `FpsProperties`
  * is not valid JSON and inline agents need to be injected.
@@ -51,6 +51,40 @@ export interface PersonalFolderInfo {
  * Returns key, id, display name, fully qualified name, and parent key.
  */
 export declare function getPersonalFolderInfo(config: OrchestratorApiConfig): Promise<PersonalFolderInfo>;
+export interface PrepareForCustomDebugParams {
+    config: StudioWebDebugConfig;
+    solutionId: string;
+    projectId: string;
+    solutionName: string;
+    folderKey: string;
+    sessionId?: string;
+}
+export interface PrepareForCustomDebugResponse {
+    solutionDebugId: string;
+    projectDebugId: string;
+}
+/**
+ * Prepare Studio Web debug IDs for a local workspace project.
+ *
+ * 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.
+ */
+export declare function prepareForCustomDebug(params: PrepareForCustomDebugParams): Promise<PrepareForCustomDebugResponse>;
+/**
+ * Fetch folder info for a specific Orchestrator folder by numeric Id.
+ *
+ * Use when the caller already knows which folder to target (e.g. `--folder-id`
+ * was passed explicitly) and personal-workspace discovery is undesirable
+ * — service-principal / CI contexts often have `Folders.Read.PersonalWorkspace`
+ * denied while still permitting access to the specific folder being targeted.
+ *
+ * Hits `GET /odata/Folders({id})`, which returns a single FolderDto. The
+ * shape returned to callers matches {@link PersonalFolderInfo} so downstream
+ * connection patching / debug-instance creation does not branch on source.
+ */
+export declare function getFolderInfoById(config: OrchestratorApiConfig, folderId: number): Promise<PersonalFolderInfo>;
 export interface BeginDebugSessionOptions {
     /** Inline agents to register with the debug session via FpsProperties. */
     inlineAgents?: InlineAgentDescriptor[];
@@ -83,6 +117,34 @@ export declare function createDebugInstance(config: OrchestratorApiConfig, jobKe
  * Poll PIMS debug instance element-executions until terminal status.
  */
 export declare function pollDebugInstanceStatus(config: OrchestratorApiConfig, instanceId: string, callbacks?: DebugCallbacks, pollInterval?: number, maxPolls?: number, jobKey?: string): Promise<DebugInstanceStatusResponse>;
+/**
+ * Fetch the incident list PIMS recorded against a finished debug instance.
+ *
+ * Mirrors the `uip <product> debug-instance incidents <id>` command but exposes
+ * the raw array so the debug lifecycle can inline it onto {@link DebugResult}.
+ * Returns an empty array if the backend reports no incidents.
+ */
+export declare function fetchDebugInstanceIncidents(config: OrchestratorApiConfig, instanceId: string): Promise<DebugIncidentResponse[]>;
+/**
+ * True when a poll-loop terminal status should pull incidents inline so the
+ * caller can surface them without a follow-up command.
+ */
+export declare function isFaultedDebugStatus(status: string): boolean;
+/**
+ * True when a terminal debug status means the run succeeded. Callers should use
+ * this (rather than hand-comparing against "Completed"/"Successful") so the
+ * success / fault partition stays defined in exactly one place.
+ */
+export declare function isSuccessfulDebugStatus(status: string): boolean;
+/**
+ * Best-effort incident lookup for a finished debug run. Returns the incident
+ * array only when the run reached a terminal-fault status AND PIMS recorded at
+ * least one incident; returns `undefined` otherwise.
+ *
+ * A fetch failure (404 / permission glitch) is logged and swallowed so it can
+ * never mask the original debug result — the incident detail is informational.
+ */
+export declare function resolveFaultIncidents(config: OrchestratorApiConfig, instanceId: string, status: string): Promise<DebugIncidentResponse[] | undefined>;
 /**
  * Parameters for the shared upload-and-debug lifecycle.
  * Callers are responsible for building the .uis package and resolving

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

@@ -19,6 +19,19 @@ export interface StudioWebDebugConfig {
     authToken: string;
     organizationUnitId?: number;
     organizationName: string;
+    /**
+     * Set when the caller has *explicitly* selected a folder (e.g. `uip maestro
+     * flow debug --folder-id 123`) and the personal-workspace discovery path
+     * should be skipped.
+     *
+     * Default discovery hits `GET /api/Folders/GetAllForCurrentUser` to find
+     * the user's personal workspace. That endpoint requires
+     * `Folders.Read.PersonalWorkspace`, which service-principal / CI tokens
+     * routinely lack — returning HTTP 403 and blocking debug entirely. When
+     * this field is set, the folder is fetched by ID via `/odata/Folders({id})`,
+     * which only requires read access to the specific folder being targeted.
+     */
+    userProvidedFolderId?: number;
 }
 export interface BeginSessionResponse {
     vncTunnelUri: string | null;
@@ -68,6 +81,7 @@ export interface DebugResult {
     solutionId?: string;
     studioWebUrl?: string;
     variables?: DebugVariablesResponse;
+    incidents?: DebugIncidentResponse[];
 }
 export interface DebugVariablesResponse {
     instanceId: string;

package/dist/src/flags/manifest-flags.d.ts

@@ -2,5 +2,6 @@
 export declare const FLAG_CONNECTOR_NODES = "canvas.mfe.dap-component";
 export declare const FLAG_EXTRACT_DOCUMENT = "canvas.nodes.extract-document";
 export declare const FLAG_HITL = "canvas.nodes.hitl";
+export declare const FLAG_LOOP_CONTAINER = "canvas.nodes.loop-container";
 /** Returns a `getFeatureFlag` callback that enables the given flags. */
 export declare function buildFeatureFlagResolver(flags: readonly string[]): (flag: string) => boolean;

package/dist/src/index.d.ts

@@ -1,16 +1,18 @@
+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";
 export { createPimsConfig } from "./client-factory";
 export type { DebugApiService, MaestroHttpErrorDetails, } from "./debug-http-client";
 export { debugPimsGet, debugPimsPatch, debugPimsPost, debugPimsPut, MaestroHttpError, orchestratorGet, orchestratorPost, parseBackendErrorBody, studioWebDelete, studioWebPost, } from "./debug-http-client";
-export type { BeginDebugSessionOptions, PersonalFolderInfo, UploadAndDebugParams, } from "./debug-service";
-export { beginDebugSession, createDebugInstance, extractStartEventId, FpsPropertiesInjectionError, getPersonalFolderInfo, getPersonalFolderKey, injectInlineAgentProcessEntries, patchConnectionOverwrites, pollDebugInstanceStatus, uploadAndDebugSolution, } from "./debug-service";
+export type { BeginDebugSessionOptions, PersonalFolderInfo, PrepareForCustomDebugParams, PrepareForCustomDebugResponse, UploadAndDebugParams, } from "./debug-service";
+export { beginDebugSession, createDebugInstance, extractStartEventId, FpsPropertiesInjectionError, fetchDebugInstanceIncidents, getFolderInfoById, getPersonalFolderInfo, getPersonalFolderKey, injectInlineAgentProcessEntries, isFaultedDebugStatus, isSuccessfulDebugStatus, patchConnectionOverwrites, pollDebugInstanceStatus, prepareForCustomDebug, resolveFaultIncidents, uploadAndDebugSolution, } from "./debug-service";
 export type { BeginSessionResponse, BreakpointUpdateRequest, ContinueOnBreakpointRequest, DebugCallbacks, DebugGetAllVariablesResponse, DebugGetVariablesResponse, DebugIncidentResponse, DebugInstanceResponse, DebugInstanceStatusResponse, DebugInstanceStatusResult, DebugResult, DebugVariablesResponse, ElementExecution, InlineAgentDescriptor, OrchestratorApiConfig, PatchVariablesRequest, StudioWebDebugConfig, } from "./debug-types";
 export { parseJsonInputOrFile, readJsonFile, resolveJsonInput, } from "./json-input";
 export { BPMN_SPEC, SUPPORTED_UIPATH_EXTENSION_TAG_NAMES, SUPPORTED_UIPATH_EXTENSION_TAGS, } from "./manifest/bpmn-spec";
 export type { BpmnExtensionType, DiscoveredConnector, DiscoveredProcess, MaestroRegistry, RegistryMetadata, } from "./manifest/types";
 export { buildQueryString } from "./query-string";
 export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, FilterCondition, FilterField, FilterOperator, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, ParsedFilters, SyncMetadata, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./registry/index.js";
-export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, FilterParseError, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, filterNodes, getConnectorConfiguration, getConnectorInfo, getNode, getNodeEnriched, hashContent, isConnectorNode, isConnectorTriggerNode, listNodes, loadIndexMetadata, loadNodeIndex, MANAGED_HTTP_CONNECTOR_KEY, parseFilterString, pullNodes, pullRemoteNodes, registerRegistryCommand, resolveNodeStorageDir, saveIndexMetadata, saveNodeIndex, searchNodes, searchNodesWithFilters, searchWithFilters, } from "./registry/index.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, FilterParseError, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, filterNodes, getConnectorConfiguration, getConnectorInfo, getNode, getNodeEnriched, hashContent, inlineMultipartFileValues, isConnectorNode, isConnectorTriggerNode, isKnownSdkNodeType, listKnownSdkNodes, listNodes, loadIndexMetadata, loadNodeIndex, MANAGED_HTTP_CONNECTOR_KEY, parseFilterString, pullNodes, pullRemoteNodes, registerRegistryCommand, resolveNodeStorageDir, saveIndexMetadata, saveNodeIndex, searchNodes, searchNodesWithFilters, searchWithFilters, } from "./registry/index.js";
 export { getEnrichedActivityMetadata, getExtensionType, getRegistry, pullRegistry, searchRegistry, } from "./registry/registry-service";
 export { CACHE_EXPIRATION_MS, loadRegistry, loadRegistryMetadata, saveRegistry, } from "./registry/storage";
 export type { DebugInstanceCommandsConfig } from "./shared-commands/debug-instances";

package/dist/src/manifest/types.d.ts

@@ -106,9 +106,11 @@ export interface DiscoveredProcess {
     key: string;
     name: string;
     processKey: string;
+    processVersion?: string;
     type: string;
     folder: string;
     folderKey: string;
+    feedId?: string;
 }
 /** The complete cached registry object. */
 export interface MaestroRegistry {

package/dist/src/query-string.d.ts

@@ -1 +1,2 @@
-export declare function buildQueryString(params: Record<string, string | number | undefined>): string;
+export type QueryValue = string | number | undefined | string[];
+export declare function buildQueryString(params: Record<string, QueryValue>): string;

package/dist/src/registry/filter-engine.d.ts

@@ -1,11 +1,11 @@
-import type { NodeManifest } from "@uipath/flow-core";
+import type { SearchableNode } from "./node-storage.js";
 import type { ParsedFilters } from "./types";
 /**
  * Filter nodes based on provided filter conditions
  */
-export declare function filterNodes(nodes: NodeManifest[], parsedFilters: ParsedFilters): NodeManifest[];
+export declare function filterNodes<T extends SearchableNode>(nodes: T[], parsedFilters: ParsedFilters): T[];
 /**
  * Advanced search with filters and keyword
  * Combines filter conditions with keyword search
  */
-export declare function searchWithFilters(nodes: NodeManifest[], keyword?: string, filters?: ParsedFilters): NodeManifest[];
+export declare function searchWithFilters<T extends SearchableNode>(nodes: T[], keyword?: string, filters?: ParsedFilters): T[];

package/dist/src/registry/index.d.ts

@@ -1,10 +1,11 @@
-export { buildFeatureFlagResolver, FLAG_CONNECTOR_NODES, FLAG_EXTRACT_DOCUMENT, } from "../flags/manifest-flags.js";
+export { buildFeatureFlagResolver, FLAG_CONNECTOR_NODES, FLAG_EXTRACT_DOCUMENT, FLAG_HITL, FLAG_LOOP_CONTAINER, } from "../flags/manifest-flags.js";
 export { registerRegistryCommand } from "./command.js";
 export { filterNodes, searchWithFilters, } from "./filter-engine.js";
 export { FilterParseError, parseFilterString } from "./filter-parser.js";
-export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, isConnectorNode, isConnectorTriggerNode, MANAGED_HTTP_CONNECTOR_KEY, } from "./integration-service-fetcher.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, inlineMultipartFileValues, isConnectorNode, isConnectorTriggerNode, MANAGED_HTTP_CONNECTOR_KEY, } from "./integration-service-fetcher.js";
 export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./integration-service-metadata.types";
-export { hashContent, loadIndexMetadata, loadNodeIndex, resolveNodeStorageDir, type SyncMetadata, saveIndexMetadata, saveNodeIndex, } from "./node-storage.js";
+export { isKnownSdkNodeType, listKnownSdkNodes } from "./known-types.js";
+export { areDerivedArtifactsCurrent, buildEssentialsIndex, buildSearchIndex, CACHE_FORMAT_VERSION, type DerivedArtifact, hashContent, isEssentialNodeType, loadIndexMetadata, loadNodeIndex, loadValidEssentialsIndex, loadValidSearchIndex, type NodeSearchSummary, rederiveNodeIndexArtifacts, resolveNodeStorageDir, type SearchableNode, type SyncMetadata, saveIndexMetadata, saveNodeIndex, } from "./node-storage.js";
 export { getNode, getNodeEnriched, listNodes, pullNodes, pullRemoteNodes, searchNodes, searchNodesWithFilters, } from "./node-sync-service.js";
 export type { SolutionContext } from "./solution-discovery.js";
 export { buildInSolutionNodeManifests, findSolutionFromCwd, readProjectEntryPointIO, } from "./solution-discovery.js";

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

@@ -1,6 +1,6 @@
 import type { NodeManifest } from "@uipath/flow-core";
 import type { CompactField, ConnectorConfiguration, ConnectorInfo, ISMetadata, TriggerObjectMetadata } from "./integration-service-metadata.types";
-export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, extractMultipartParameters, MANAGED_HTTP_CONNECTOR_KEY, } from "@uipath/integrationservice-sdk";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, extractMultipartParameters, inlineMultipartFileValues, MANAGED_HTTP_CONNECTOR_KEY, } from "@uipath/integrationservice-sdk";
 export declare function isConnectorNode(node: NodeManifest): boolean;
 export declare function isConnectorTriggerNode(node: NodeManifest): boolean;
 export declare function extractTriggerEventParameters(metadata: TriggerObjectMetadata, operationName: string): CompactField[];

package/dist/src/registry/known-types.d.ts

@@ -0,0 +1,17 @@
+import type { NodeManifest } from "@uipath/flow-core";
+/**
+ * Cheap, network-free check: does the SDK bundle know about this node type?
+ *
+ * Case-insensitive match against the full OOTB + inline-agent catalog. Returns
+ * `true` when the type is something the platform supports (but may be gated
+ * for the current tenant), `false` when it is genuinely unknown.
+ */
+export declare function isKnownSdkNodeType(nodeType: string): boolean;
+/**
+ * Return every node manifest the SDK bundle knows about (OOTB + inline agents).
+ *
+ * Used by `registry list --all` to surface FF-gated nodes that exist in the
+ * SDK catalog but were filtered out of the tenant's manifest. The list is a
+ * fresh array per call so callers can mutate freely.
+ */
+export declare function listKnownSdkNodes(): NodeManifest[];

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

@@ -1,4 +1,24 @@
 import type { NodeManifest } from "@uipath/flow-core";
+export declare const CACHE_FORMAT_VERSION = 1;
+export interface SearchableNode {
+    nodeType?: string;
+    category?: string;
+    tags?: string[];
+    version?: string;
+    description?: string;
+    display?: {
+        label?: string;
+        description?: string;
+    };
+    [key: string]: unknown;
+}
+export type NodeSearchSummary = SearchableNode;
+export interface DerivedArtifact<T> {
+    cacheVersion: number;
+    sourceHash: string;
+    generatedAt: number;
+    nodes: T[];
+}
 /**
  * Metadata about a node source sync operation
  */
@@ -6,6 +26,7 @@ export interface SyncMetadata {
     lastSync: number;
     nodeCount: number;
     hash: string;
+    cacheVersion?: number;
 }
 /**
  * Resolve the absolute path to the nodes storage directory.
@@ -21,10 +42,13 @@ export declare function resolveNodeStorageDir(): Promise<string>;
  * @returns Hex string of the hash
  */
 export declare function hashContent(content: string): Promise<string>;
+export declare function buildSearchIndex(nodes: NodeManifest[]): NodeSearchSummary[];
+export declare function isEssentialNodeType(nodeType: string | undefined): boolean;
+export declare function buildEssentialsIndex(nodes: NodeManifest[]): NodeManifest[];
 /**
- * Save nodes directly to the index file
- * Bypasses the source aggregation and saves nodes directly
- * Also updates the index metadata
+ * Save nodes directly to the index file.
+ * Bypasses the source aggregation and saves nodes directly.
+ * Also updates the index metadata and derived read-path artifacts.
  *
  * @param nodes - Array of nodes to save
  * @returns Number of nodes saved
@@ -49,3 +73,7 @@ export declare function saveIndexMetadata(metadata: SyncMetadata): Promise<void>
  * @returns Metadata if exists, null otherwise
  */
 export declare function loadIndexMetadata(): Promise<SyncMetadata | null>;
+export declare function loadValidSearchIndex(): Promise<NodeSearchSummary[] | null>;
+export declare function loadValidEssentialsIndex(): Promise<NodeManifest[] | null>;
+export declare function areDerivedArtifactsCurrent(): Promise<boolean>;
+export declare function rederiveNodeIndexArtifacts(): Promise<number>;

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

@@ -1,4 +1,5 @@
 import type { NodeManifest } from "@uipath/flow-core";
+import { type NodeSearchSummary } from "./node-storage.js";
 import type { ParsedFilters } from "./types";
 interface PullNodesOptions {
     force?: boolean;
@@ -45,6 +46,11 @@ export declare function pullRemoteNodes(): Promise<PullRemoteNodesResult>;
 export declare function listNodes(options?: {
     local?: boolean;
 }): Promise<NodeManifest[]>;
+interface SearchSummaryWithAvailability {
+    node: NodeSearchSummary;
+    availableOnTenant: boolean;
+}
+export declare function searchNodeSummariesWithAvailability(keyword?: string, filters?: ParsedFilters): Promise<SearchSummaryWithAvailability[]>;
 /**
  * Search for nodes by keyword
  * Searches across nodeType, category, tags, and display.label

package/dist/src/registry/solution-discovery.d.ts

@@ -20,6 +20,18 @@ export declare function findSolutionFromCwd(): Promise<SolutionContext | null>;
 /**
  * Read entry-points.json from a project directory.
  * Tries flat layout first, then content/ subdirectory.
+ *
+ * Falls back to extracting `variables.globals` from the project's `.flow`
+ * file whenever no usable `entry-points.json` is found in either candidate
+ * location — that is, when the file is missing, unreadable, contains
+ * invalid JSON, or carries an empty `entryPoints` array. `flow init` and
+ * `flow variable add` do not emit `entry-points.json` — the packager
+ * generates it into a temp staging dir at pack time — so without this
+ * fallback the in-solution registry would always report empty
+ * inputDefinition/outputDefinition for unpacked source flow projects. The
+ * broader trigger (not strictly ENOENT) is intentional: a corrupted or
+ * stale `entry-points.json` should still let the `.flow` source recover
+ * the typed contract.
  */
 export declare function readProjectEntryPointIO(projectDir: string): Promise<ProjectEntryPointIO>;
 /**

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

@@ -10,5 +10,7 @@ export interface InstanceCommandsConfig {
     includeElementExecutions?: boolean;
     /** Whether --folder-key is required (default: true) */
     folderKeyRequired?: boolean;
+    /** Whether --folder-key is required for list (default: folderKeyRequired) */
+    listFolderKeyRequired?: boolean;
 }
 export declare const registerSharedInstanceCommands: (program: Command, config: InstanceCommandsConfig) => void;

package/dist/src/with-pims-call.d.ts

@@ -1,2 +1,38 @@
 import type { PimsApiConfig } from "./types";
-export declare function withPimsCall<T>(fn: (config: PimsApiConfig) => Promise<T>, errorMessage: string): Promise<T | undefined>;
+/**
+ * Optional metadata describing the resource being fetched. When provided, the
+ * helper formats a resource-aware 404 message (e.g. `"Incident not found: <id>"`)
+ * instead of falling back to the generic `errorMessage`.
+ */
+export interface PimsResourceHint {
+    /** Resource label (e.g. `"incident"`, `"process"`, `"instance"`). Capitalised in the message. */
+    resource: string;
+    /** The resource identifier the caller looked up (e.g. the incident id). */
+    id?: string;
+}
+/**
+ * Wrap a PIMS API call. On failure, branches on HTTP status to surface a
+ * stable, machine-readable error envelope:
+ *
+ * | HTTP            | Result                | Code                    |
+ * |-----------------|-----------------------|-------------------------|
+ * | 404             | `Failure`             | `NotFound`              |
+ * | 401             | `AuthenticationError` | `Unauthorized`          |
+ * | 403             | `AuthenticationError` | `Forbidden`             |
+ * | 5xx             | `Failure`             | `ServerError_<status>`  |
+ * | Other 4xx       | `Failure`             | `Http_<status>`         |
+ * | Network failure | `Failure`             | `NetworkError`          |
+ * | Unknown shape   | `Failure`             | `UnknownError`          |
+ * | Config failure  | `Failure`             | `ConfigError`           |
+ *
+ * Pass {@link PimsResourceHint} (e.g. `{ resource: "incident", id }`) to get a
+ * resource-aware 404 message (`"Incident not found: <id>"`). When omitted, the
+ * helper falls back to `errorMessage`.
+ *
+ * For `PimsApiError`s the wire envelope also carries a `Context` block sourced
+ * from the typed error (`httpStatus`, `endpoint`, `method`, `errorCode`,
+ * `traceId`, `requestId` when present) and `Instructions` shaped by
+ * `pimsFailureInstructions`. Non-PimsApiError failures fall back to
+ * `extractErrorMessage(error)` for `Instructions` and emit no `Context`.
+ */
+export declare function withPimsCall<T>(fn: (config: PimsApiConfig) => Promise<T>, errorMessage: string, hint?: PimsResourceHint): Promise<T | undefined>;