@uipath/flow-tool 1.200.0-preview.120 → 1.201.0-preview.121

package/dist/ro-VZUZTAMR-tccygznf.js

@@ -0,0 +1,32 @@
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-wckvcay0.js";
+
+// ../../node_modules/@uipath/flow-migrations/dist/ro-VZUZTAMR.js
+var createMigration_invalidDownInput_message = "Input nu este valid pentru down-migration {{fromVersion}} → {{toVersion}}";
+var createMigration_invalidDownOutput_message = "Output nu este valid pentru down-migration {{fromVersion}} → {{toVersion}}";
+var createMigration_invalidInput_message = "Intrare nevalidă pentru migrare {{fromVersion}} → {{toVersion}}";
+var createMigration_invalidOutput_message = "Ieșire nevalidă pentru migrarea {{fromVersion}} → {{toVersion}}";
+var downgradeWorkflow_missingDown_message = "Lipsește calea de downgrade {{fromVersion}} → {{toVersion}}";
+var downgradeWorkflow_noPath_message = "Nu există nicio cale de retrogradare de la {{fromVersion}} la {{toVersion}}";
+var migrate_chain_noMigrationFound_message = "Nu a fost găsită nicio migrare de la versiunea {{current}}. Nu se poate ajunge la {{toVersion}}.";
+var ro_default = {
+  createMigration_invalidDownInput_message,
+  createMigration_invalidDownOutput_message,
+  createMigration_invalidInput_message,
+  createMigration_invalidOutput_message,
+  downgradeWorkflow_missingDown_message,
+  downgradeWorkflow_noPath_message,
+  migrate_chain_noMigrationFound_message
+};
+export {
+  migrate_chain_noMigrationFound_message,
+  downgradeWorkflow_noPath_message,
+  downgradeWorkflow_missingDown_message,
+  ro_default as default,
+  createMigration_invalidOutput_message,
+  createMigration_invalidInput_message,
+  createMigration_invalidDownOutput_message,
+  createMigration_invalidDownInput_message
+};
+
+//# debugId=101FFC56DC130BE464756E2164756E21

package/dist/{ro-WMQEVD7D-6mtq0e6b.js → ro-WLKX6HF5-fcbe2zz8.js}

@@ -1,16 +1,19 @@
 import"./packager-tool-c23zrhj8.js";
 import"./packager-tool-wckvcay0.js";
 
-// ../../node_modules/@uipath/flow-schema/dist/ro-WMQEVD7D.js
+// ../../node_modules/@uipath/flow-schema/dist/ro-WLKX6HF5.js
 var agentInputRefs_nodeCollision_message = "Nodul „{{id}}” conține „{{sep}}”. Agenții inline codifică referințele prin unirea segmentelor de cale cu „{{sep}}”, astfel încât „$vars.{{id}}.output.field” ar intra în conflict cu o altă cale în timpul rulării. Redenumiți nodul pentru a elimina „{{sep}}”.";
 var agentInputRefs_reservedNamespace_message = '"$agent.{{ref}}" este un spațiu de nume intern al runtime-ului agentului din Flow și nu poate fi utilizat direct în prompturi. Faceți referire în schimb la variabila de flux prin "$vars.{{ref}}" sau "$metadata.{{ref}}".';
 var agentInputRefs_unresolvedRef_message = 'Promptul face referire la "$vars.{{ref}}", dar nu există nicio variabilă workflow sau niciun nod „{{rootSegment}}”. Adăugați variabila/nodul în flux sau eliminați referința.';
-var agentInputRefs_variableCollision_message = "Variabila workflow „{{id}}” conține „{{sep}}”. Agenții inline codifică referințele prin unirea segmentelor de cale cu „{{sep}}”, astfel încât „{{id}}” ar intra în conflict cu o altă cale în timpul rulării. Redenumiți variabila pentru a elimina „{{sep}}”.";
+var agentInputRefs_variableCollision_message = 'Variabila de proces "{{id}}" conține "{{sep}}". Agenții inline codifică referințele prin concatenarea segmentelor de cale cu "{{sep}}", astfel încât "{{id}}" ar intra în conflict cu o altă cale în timpul execuției. Redenumiți variabila pentru a elimina "{{sep}}".';
 var conditionExpression_decisionWrapped_message = "Condiție nevalidă pentru „{{nodeLabel}}”: {{error}}";
 var conditionExpression_empty_message = "Expresia este goală";
 var conditionExpression_incomplete_message = "Expresie incompletă";
 var conditionExpression_invalid_message = "Expresie invalidă";
-var conditionExpression_required_message = "Este necesară o expresie de condiție";
+var conditionExpression_required_message = "Adăugați o condiție";
+var conversationalVoiceEndCall_callContextInvalid_message = "{{label}}: Contextul apelului trebuie asociat cu un obiect de context al apelului";
+var conversationalVoice_callContextInvalid_message = "{{label}}: Contextul apelului trebuie asociat cu un obiect de context al apelului";
+var conversationalVoice_callContextRequired_message = "{{label}}: Contextul apelului este necesar când vocea este activată";
 var dataTransform_customScriptMissing_message = "Operațiunea de script personalizat „{{nodeLabel}}” nu are niciun script";
 var dataTransform_filterMissingField_message = "Condiției de filtrare „{{nodeLabel}}” îi lipsește un câmp";
 var dataTransform_filterNoConditions_message = "Operațiunea de filtrare „{{nodeLabel}}” nu are condiții";
@@ -21,7 +24,7 @@ var dataTransform_mapMissingField_message = "În maparea câmpurilor pentru „{
 var dataTransform_mapNoMappings_message = "Operațiunea de mapare „{{nodeLabel}}” necesită cel puțin o mapare a câmpurilor atunci când câmpurile originale nu sunt păstrate";
 var dataTransform_missingCollection_message = "„{{nodeLabel}}” nu are o variabilă de colecție";
 var dataTransform_noOperations_message = '"{{nodeLabel}}" nu are nicio operațiune configurată';
-var escalation_appRequired_message = "{{label}}: Action App este necesară";
+var escalation_appRequired_message = "Selectează o aplicație de acțiune";
 var escalation_nameRequired_message = "{{label}}: Numele escaladării este obligatoriu";
 var escalation_quickFormDuplicateFieldLabel_message = "{{label}}: Mai multe câmpuri sunt etichetate „{{fieldLabel}}” — sarcina de escaladare ar păstra doar unul dintre ele. Faceți etichetele câmpurilor unice";
 var escalation_recipientRequired_message = "{{label}}: Destinatarul escaladării este obligatoriu";
@@ -31,7 +34,7 @@ var governance_maxTokensExceeded_message = "Numărul maxim de tokenuri per răsp
 var governance_modelNotAvailable_message = "{{model}} model nu este permis, impus de politica de guvernanță: {{policyName}}";
 var governance_noAllowedModel_message = "Nu este selectat niciun model permis, impus de politica de guvernanță: {{policyName}}";
 var governance_temperatureExceeded_message = "Temperatura depășește {{maxTemperature}}. Regula este aplicată prin politica de guvernanță: {{policyName}}";
-var hitlQuickForm_emptySchema_message = "Formularul rapid trebuie să aibă cel puțin un câmp";
+var hitlQuickForm_emptySchema_message = "Adăugați cel puțin un câmp";
 var hitlQuickForm_fieldLabelRequired_message = "Eticheta câmpului este obligatorie";
 var outputMapping_missing_message = '"{{nodeLabel}}" nu are mapare de ieșire pentru "{{varId}}"';
 var schemaValidator_genericKeyword_message = '"{{fieldName}}" pe "{{nodeLabel}}": {{detail}}';
@@ -42,7 +45,7 @@ var schemaValidator_outOfRange_message = '"{{fieldName}}" pe "{{nodeLabel}}" {{d
 var schemaValidator_required_message = '"{{fieldName}}" este obligatoriu în "{{nodeLabel}}"';
 var schemaValidator_typeMismatch_message = "„{{fieldName}}” din „{{nodeLabel}}” așteaptă {{type}}";
 var schemaValidator_validation_genericError = "Eroare de validare";
-var triggerRequired_message = "Workflow trebuie să aibă cel puțin un nod de declanșare";
+var triggerRequired_message = "Procesul trebuie să aibă cel puțin un nod de declanșare";
 var ro_default = {
   agentInputRefs_nodeCollision_message,
   agentInputRefs_reservedNamespace_message,
@@ -53,6 +56,9 @@ var ro_default = {
   conditionExpression_incomplete_message,
   conditionExpression_invalid_message,
   conditionExpression_required_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoice_callContextRequired_message,
   dataTransform_customScriptMissing_message,
   dataTransform_filterMissingField_message,
   dataTransform_filterNoConditions_message,
@@ -120,6 +126,9 @@ export {
   dataTransform_filterNoConditions_message,
   dataTransform_filterMissingField_message,
   dataTransform_customScriptMissing_message,
+  conversationalVoice_callContextRequired_message,
+  conversationalVoice_callContextInvalid_message,
+  conversationalVoiceEndCall_callContextInvalid_message,
   conditionExpression_required_message,
   conditionExpression_invalid_message,
   conditionExpression_incomplete_message,
@@ -131,4 +140,4 @@ export {
   agentInputRefs_nodeCollision_message
 };
 
-//# debugId=28CBAD49AA1340B364756E2164756E21
+//# debugId=4E1E145A0E7B2E5064756E2164756E21

package/dist/ru-GSCT4ARZ-3TVTUGWP-bbg6360z.js

@@ -0,0 +1,15 @@
+import"./packager-tool-pvgqbm48.js";
+import {
+  init_esm_shims
+} from "./packager-tool-jpcm3xas.js";
+import"./packager-tool-c19w8vg9.js";
+import"./packager-tool-wckvcay0.js";
+
+// ../../node_modules/@uipath/flow-converter/dist/ru-GSCT4ARZ-3TVTUGWP.js
+init_esm_shims();
+var ru_default = {};
+export {
+  ru_default as default
+};
+
+//# debugId=A4522EAA5225E73C64756E2164756E21

package/dist/{serialization-3RH6P643-zxj2yyfh.js → serialization-GTFWODSH-ajd6b7n2.js}

@@ -17,6 +17,7 @@ import {
   VALUE_FREE_CONDITIONS,
   buildAgentInputTypeResolver,
   buildCollectionAccessor,
+  canPruneAgentInputs,
   collectArtifactDescendants,
   collectCompositeConnectorInputs,
   collectInlineAgentClusterInputs,
@@ -53,6 +54,7 @@ import {
   mergeCompositeConnectorInputs,
   parseMustacheSegments,
   protectJsonStrings,
+  resolveUpdateRecordSource,
   restoreJsonStrings,
   rewriteInputTokensToSource,
   rewriteStringsDeep,
@@ -63,16 +65,16 @@ import {
   stripVarsPrefix,
   toServerlessWorkflow,
   toXml
-} from "./packager-tool-3ahtr7dn.js";
-import"./packager-tool-1q1bg65m.js";
-import"./packager-tool-jqtspg41.js";
-import"./packager-tool-hkrpcn6d.js";
-import"./packager-tool-fr5b9qs6.js";
-import"./packager-tool-9bnpe8n1.js";
-import"./packager-tool-ahm4ymrp.js";
+} from "./packager-tool-jeh5j2xy.js";
+import"./packager-tool-3wf3tkrc.js";
+import"./packager-tool-03knb0er.js";
+import"./packager-tool-pvgqbm48.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-ef2aypt3.js";
+import"./packager-tool-jpcm3xas.js";
 import"./packager-tool-c19w8vg9.js";
-import"./packager-tool-3yjtbs1y.js";
-import"./packager-tool-060a9knt.js";
+import"./packager-tool-1yy9x4vk.js";
+import"./packager-tool-c23zrhj8.js";
 import"./packager-tool-wckvcay0.js";
 export {
   toXml,
@@ -85,6 +87,7 @@ export {
   rewriteStringsDeep,
   rewriteInputTokensToSource,
   restoreJsonStrings,
+  resolveUpdateRecordSource,
   protectJsonStrings,
   parseMustacheSegments,
   mergeCompositeConnectorInputs,
@@ -121,6 +124,7 @@ export {
   collectInlineAgentClusterInputs,
   collectCompositeConnectorInputs,
   collectArtifactDescendants,
+  canPruneAgentInputs,
   buildCollectionAccessor,
   buildAgentInputTypeResolver,
   VALUE_FREE_CONDITIONS,
@@ -141,4 +145,4 @@ export {
   AGGREGATION_OPTIONS
 };
 
-//# debugId=42A593898735610364756E2164756E21
+//# debugId=9DF9AF331A3BE3CE64756E2164756E21

package/dist/services/flow-migration-check.d.ts

@@ -7,8 +7,9 @@ import { type MigrationErrorTracker, type MigrationWorkflow } from "@uipath/flow
  * this module is the shared plumbing that both `flow migrate` and `flow
  * validate` use to do so (UV-15030).
  *
- * `migrateWorkflow` does NOT throw on a failed step; it returns the ORIGINAL
- * workflow with `migrated: false` and a populated `error: { step, message }`.
+ * `migrateWorkflowToFloor` does NOT throw on a failed step; it returns the
+ * ORIGINAL workflow with `migrated: false` and a populated
+ * `error: { step, message }`.
  * The offending field paths are only reachable through the optional
  * `errorTracker`, not the returned `error`. `captureMigrationIssues` wires that
  * tracker up so callers can enrich the bare "Invalid input" message with the
@@ -22,7 +23,7 @@ export declare function captureMigrationIssues(): {
  * Human-facing explanation for a failed workflow migration step, shared by
  * `flow migrate` (as a thrown error message) and `flow validate` (as a
  * validation issue). `step` and `rawMessage` come straight from
- * `migrateWorkflow`'s returned `error`; `fieldPaths` come from
+ * `migrateWorkflowToFloor`'s returned `error`; `fieldPaths` come from
  * `captureMigrationIssues`.
  */
 export declare function formatMigrationFailureMessage(step: string, rawMessage: string, fieldPaths: string[]): string;
@@ -36,16 +37,19 @@ export type ForwardMigrationCheck = {
     fieldPaths: string[];
 };
 /**
- * Run the forward migration Studio Web would run when opening this flow, in
- * memory — no write, no network. Returns `{ ok: false, ... }` only when a
- * migration STEP fails (the flow is at a known version but its shape is
+ * Run the floor migration Studio Web would run when opening this flow, in
+ * memory — no write, no network: upgrade to `runtimeVersion`, then project
+ * back down to the fleet write floor. Returns `{ ok: false, ... }` only when
+ * a migration STEP fails (the flow is at a known version but its shape is
  * invalid for the next step); that flow will not open in Studio Web until
  * fixed.
  *
- * Returns `{ ok: true }` when the flow migrates cleanly, is already current,
- * OR when the chain can't be built at all — a missing/unknown/newer-than-
- * bundled `version` makes `migrateWorkflow` throw before running any step.
- * That last case means the CLI's bundled migrations are out of step with the
- * flow (version skew), which is not a flow defect we should hard-fail on.
+ * Returns `{ ok: true }` when the flow migrates cleanly, is already at the
+ * floor, OR when the chain can't be built at all — a missing/unknown/newer-
+ * than-runtime `version` means the CLI's bundled migrations are out of step
+ * with the flow (version skew), which is not a flow defect we should
+ * hard-fail on. `migrateWorkflowToFloor` folds that case into its returned
+ * `error` instead of throwing, so probe chain-buildability up front with
+ * `getMigrationChain` to keep skew fail-open.
  */
 export declare function checkForwardMigration(rawWorkflow: MigrationWorkflow): ForwardMigrationCheck;

package/dist/services/flow-validate-service.d.ts

@@ -83,15 +83,21 @@ export declare class FlowValidateService {
     private loadCurrentManifestMapUncached;
     validateFile(flowFilePath: string): Promise<FlowValidateResult>;
     /**
-     * Forward-migration preflight (UV-15030).
+     * Floor-migration preflight (UV-15030).
      *
-     * Studio Web runs the `@uipath/flow-migrations` chain when it opens a
-     * `.flow`; a flow that fails a migration step (e.g. 1.3->1.4) passes every
+     * Studio Web runs the `@uipath/flow-migrations` floor chain when it opens
+     * a `.flow` (up to the runtime version, projected back down to the write
+     * floor); a flow that fails a migration step (e.g. 1.3->1.4) passes every
      * structural/semantic check here yet never opens in the browser. The CLI
      * bundles the same engine, so we run it in-memory (no write, no network)
      * and turn a failed step into a blocking error naming the offending
-     * fields. A flow that migrates cleanly, is already current, or carries an
-     * unknown/skewed version yields no issue — see `checkForwardMigration`.
+     * fields. A flow that round-trips cleanly through the floor pipeline or
+     * carries an unknown/skewed version yields no issue — see
+     * `checkForwardMigration`.
+     *
+     * `$ref` chunks are resolved before the check — the floor projection
+     * validates the full document shape (e.g. `layout.nodes`), which an
+     * unresolved `$ref` placeholder would fail.
      */
     private validateForwardMigration;
     /**
@@ -175,6 +181,54 @@ export declare class FlowValidateService {
      * right place.
      */
     private buildPromptInputRefIssues;
+    /**
+     * Inline-agent input-scope integrity (UV-15030).
+     *
+     * `validateAgentPromptInputRefs` checks the prompt token against the
+     * agent's `inputSchema`; nothing checked what the schema key itself
+     * points at. The converter binds each declared input by structurally
+     * decoding the key (`<node>__output__<field>` →
+     * `$vars.<node>.output.<field>`), so a key naming a node that was
+     * renamed, deleted, or wired after the agent produces a `$vars`
+     * reference that resolves to nothing. Studio Web checks this when it
+     * opens the flow and rejects it with "Prompt references
+     * `$vars.<node>.output.<field>` but that variable is not available in
+     * this scope" — the CLI reported the same flow as Valid, so the failure
+     * only showed up after a solution upload and a browser round-trip.
+     *
+     * References come from both binding surfaces: the agent's declared
+     * `inputSchema` keys and any explicit `inputs.agentInputVariables[]`
+     * binding on the node.
+     *
+     * Scope is per graph — the root's nodes for the root, a subflow's own
+     * nodes for that subflow — because parent-flow `$vars` are not visible
+     * inside a subflow (see `validateGlobalTriggerBindings`).
+     *
+     * A reference to a node that does not exist in this scope is an `error`
+     * (Studio Web will refuse to open the flow). A reference to a node that
+     * exists but that no edge path reaches before the agent is a `warning`:
+     * the output genuinely is not written yet when the agent runs, but
+     * flagging it should not fail a build over an unusual topology.
+     */
+    private validateAgentInputScopeRefs;
+    /**
+     * Collect the `$vars.<nodeId>.output.<field>` references one inline-agent
+     * node depends on, keyed by node id. Each entry carries a human-readable
+     * origin (used verbatim in messages) and the output field name so the
+     * caller can validate field existence on the producer node.
+     *
+     * Deduplicates by node id — a second ref to the same producer is
+     * dropped because the node-existence / upstream checks only need it
+     * once. Field-level refs are collected separately (per nodeId+field)
+     * so each invalid field is reported individually.
+     */
+    private collectAgentVarRefs;
+    /**
+     * Every node that can run before `targetId` — reverse BFS over the
+     * graph's edges. `incoming` maps a node id to the ids of the nodes with
+     * an edge into it, built once per graph by the caller.
+     */
+    private collectUpstreamNodeIds;
     /**
      * Return the declared-schema key a prompt variable token maps to, or
      * `undefined` when the token is not the canonical `input.<key>` form.
@@ -218,6 +272,43 @@ export declare class FlowValidateService {
      * `validateGlobalVariableUniqueness`.
      */
     private validateGlobalTriggerBindings;
+    /**
+     * Entry-point contract integrity for flow inputs (root-cause:
+     * skill-flow-calculator).
+     *
+     * Packaging derives an entry point's input contract from
+     * `getEffectiveTriggerInputs` (`@uipath/flow-schema`), which has two
+     * branches: it reads the trigger manifest's
+     * `outputDefinition.output.schema.properties`, or — when that schema is
+     * absent — keeps only globals where
+     * `direction === "in" && triggerNodeId === startNode.id`. Core triggers
+     * declare no output schema, so for a hand-authored flow the second branch is
+     * the live one and an `in` global that is unbound (or bound to a node that
+     * is not a trigger in this scope) is dropped from `input.properties`. The
+     * deployed process or trigger then exposes no way to pass that input.
+     *
+     * Nothing else surfaces it. `flow validate` and `flow format` stay green,
+     * `flow debug --inputs` binds values into the debug instance regardless of
+     * this field (so an end-to-end debug run looks correct), and
+     * `validateGlobalTriggerBindings` above fires only when the flow *reads*
+     * `$vars.<trigger>.output.<id>` — which an unbound global typically does
+     * not, since it reads as a bare `$vars.<id>`. That leaves `flow pack` as the
+     * first place the loss is observable, and it does not warn.
+     *
+     * Severity: `warning`, matching the sibling validator — surface it at design
+     * time without failing an otherwise-valid flow. Scope-local: each subflow is
+     * checked against its own triggers and globals.
+     *
+     * The manifest branch is decided **per trigger**, because a scope can hold
+     * several triggers and each is its own entry point (see `resolveTriggerNodeId`
+     * in `variable-service.ts`). A flow pairing a schema-declaring trigger with a
+     * core trigger still drops an unbound global from the core trigger's
+     * contract, so the check bails out only when *every* trigger in scope is
+     * manifest-driven, and the fix hint names only the globals-driven triggers. An
+     * id some manifest-driven entry point already declares is left alone — that
+     * value has a way in regardless of `triggerNodeId`.
+     */
+    private validateUnboundInputGlobals;
     /**
      * Resource-node bindings integrity (residual roadmap §A4, [MST-9712]).
      *
@@ -249,6 +340,29 @@ export declare class FlowValidateService {
      * (matches A4's iteration shape for consistency).
      */
     private validateConnectionIdReuse;
+    /**
+     * Duplicate process/function target detection (UV-15294).
+     *
+     * `resolveProcessTargetKey` returns the key the runtime routes a process
+     * node on: the definition's `model.bindings.resourceKey` (e.g. a non-GUID
+     * `Shared.<process>`) when present, else the process GUID from the node
+     * type. Two nodes that resolve to the same key invoke the same
+     * process/function — even when their node types differ. When those nodes
+     * carry *different* display labels, that usually means a node was copied
+     * and its target was never re-pointed — the flow author believes two
+     * differently-named steps call two different functions, but they resolve
+     * to one. `flow validate` passes today and the mis-route only shows up as
+     * wrong runtime output (the reporter's "extractQuoteWithIxp ran the
+     * workbook generator").
+     *
+     * Severity: `warning` — invoking the same subprocess from two steps can be
+     * intentional, so this informs rather than blocks. Same-labeled duplicates
+     * are transparent (not misleading) and are not flagged.
+     *
+     * Scope: top-level `workflow.nodes` + every `workflow.subflows[].nodes`
+     * (matches the A4/A6 iteration shape for consistency).
+     */
+    private validateDuplicateProcessTargets;
     /**
      * Connector-binding shape check (MST-9810, upstream UiPath/cli#2027).
      *

package/dist/services/node-service.d.ts

@@ -88,6 +88,52 @@ export declare const PROCESS_NODE_PREFIXES: string[];
 export declare function isProcessNode(manifest: {
     nodeType: string;
 }): boolean;
+export interface ProcessTarget {
+    /**
+     * The key the runtime routes on: the definition's
+     * `model.bindings.resourceKey` when present (e.g. a non-GUID
+     * `Shared.<process>`), otherwise the process GUID from the node type.
+     */
+    key: string;
+    /**
+     * The runtime target kind — `model.bindings.resourceSubType` ("Process",
+     * "Api", "Agent", …), defaulting to "Process" the same way
+     * `createProcessBindings` does. Two nodes are the same target only when
+     * BOTH key and subType match: an RPA process and an API workflow that
+     * happen to share a resourceKey are still distinct targets.
+     */
+    subType: string;
+}
+/**
+ * Resolve the runtime process/queue/app target of a process node: its
+ * resourceKey (see `ProcessTarget.key`) plus its resource subtype. Two nodes
+ * with different node types but the same (key, subType) resolve to the SAME
+ * target — so callers that group by "which process does this node call" must
+ * key on both, not on the node type.
+ *
+ * Definitions are keyed by `nodeType` + `version` across flow validation (a
+ * flow may legitimately carry the same `nodeType` at different versions with
+ * different resourceKeys), so prefer the definition whose `version` matches the
+ * node's `typeVersion`; fall back to the first same-type definition when the
+ * node carries no version or none match.
+ *
+ * Returns undefined for non-process nodes. Throws (via extractProcessGuid) when
+ * a process-prefixed type has no valid GUID and no definition key — matching
+ * the existing collectNodeBindingResourceKeys behavior.
+ */
+export declare function resolveProcessTarget(node: {
+    type: string;
+    typeVersion?: string;
+}, definitions?: Array<Record<string, unknown>>): ProcessTarget | undefined;
+/**
+ * Convenience wrapper returning only {@link ProcessTarget.key} — the binding
+ * resourceKey a process node contributes. Callers that also need to
+ * distinguish target kinds should use {@link resolveProcessTarget}.
+ */
+export declare function resolveProcessTargetKey(node: {
+    type: string;
+    typeVersion?: string;
+}, definitions?: Array<Record<string, unknown>>): string | undefined;
 /**
  * Safety net: ensure every process/agent node in the workflow has corresponding
  * entries in the workflow `bindings` array and that `<bindings.*>` placeholders

package/dist/services/node-validators/ceql-query-validator.d.ts

@@ -1,14 +1,40 @@
 import type { FlowNodeValidator } from "./types.js";
-export interface CeqlQuotedFieldIssue {
-    /** The field name found in quotes, without the quotes. */
-    fieldName: string;
-    /** The whole input value with the field-name quotes removed. */
-    fixedValue: string;
-}
 /**
- * Finds every quoted field name on a comparison's left side in one input value.
- * `fixedValue` un-quotes all of them at once, so the entry set shares one
- * corrected value.
+ * A filter value reaches the connector either as a plain string or as a `=js:`
+ * expression that concatenates literals with runtime values. Both carry the
+ * same CEQL grammar, so the rules read one skeleton: the text the author typed,
+ * with every runtime value standing in as a hole.
+ *
+ * Only a concatenation of strings is readable. A call, an array join or a
+ * conditional decides the whole value at runtime, so a skeleton would be
+ * invented rather than read. The lexer returns `undefined` for those and the
+ * value is left alone without an issue: a wrong warning on a working filter
+ * costs more than a missed defect.
+ */
+export type CeqlFragment = {
+    kind: "text";
+    text: string;
+} | {
+    kind: "hole";
+};
+/**
+ * Lexes one filter value into fragments. Returns `undefined` when the value
+ * carries no statically readable CEQL.
  */
-export declare function findCeqlQuotedFieldNames(value: string): CeqlQuotedFieldIssue[];
+export declare function lexCeqlFilterValue(value: string): CeqlFragment[] | undefined;
+export type CeqlRuleId = "quoted-field" | "double-quoted-value" | "operator-alias";
+export interface CeqlFilterIssue {
+    rule: CeqlRuleId;
+    /** The token that broke the rule. A runtime value reads as `<expression>`. */
+    token: string;
+    /**
+     * The whole input value, corrected. Offered only for a plain string: the
+     * lexer keeps no JavaScript source, so a `=js:` value gets a prescriptive
+     * message instead.
+     */
+    fixedValue?: string;
+    message: string;
+}
+/** Finds every CEQL grammar defect in one input value. */
+export declare function findCeqlFilterIssues(value: string): CeqlFilterIssue[];
 export declare const ceqlQueryValidator: FlowNodeValidator;

package/dist/services/node-validators/expression-prefix-validator.d.ts

@@ -36,8 +36,9 @@ import type { FlowNodeValidator } from "./types.js";
  * - Decision / Switch / HTTP branch condition expressions — those are always
  *   parsed as JS, so `=js:` is forbidden, not required. Covered by the
  *   `condition-expression` rule in `@uipath/flow-schema`.
- * - Variable updates — `bpmn-moddle.ensureJsPrefix` already auto-prefixes and
- *   warns; covered by `variable-update-service`.
+ * - Variable updates — `variableUpdates[].expression` is a structured
+ *   ExpressionValue object, not a `=js:` string, so the leading-prefix rule
+ *   does not apply to it at all.
  * - End node output `source` and subflow input `source` — those ARE
  *   expression-mode fields where `=js:` is valid. A future check can lint
  *   their *contents* (resolvability) but the leading-`=js:` rule does not

package/dist/services/node-validators/index.d.ts

@@ -1,6 +1,7 @@
 import type { FlowNodeValidator } from "./types.js";
 export { activityTypeIdValidator } from "./activity-type-id-validator.js";
-export { ceqlQueryValidator, findCeqlQuotedFieldNames, } from "./ceql-query-validator.js";
+export type { CeqlFilterIssue, CeqlFragment, CeqlRuleId, } from "./ceql-query-validator.js";
+export { ceqlQueryValidator, findCeqlFilterIssues, lexCeqlFilterValue, } from "./ceql-query-validator.js";
 export { connectorNodeValidator } from "./connector-validator.js";
 export { crossNodeBindingValidator, findCrossNodeBindingReferences, scanDetailForCrossNodeBindings, } from "./cross-node-binding-validator.js";
 export { expressionPrefixValidator } from "./expression-prefix-validator.js";

package/dist/services/project-artifacts.d.ts

@@ -1 +1,14 @@
-export { ensureProjectArtifacts, type ProjectArtifactsResult, } from "@uipath/common";
+import type { ProjectArtifactsResult } from "@uipath/solution-sdk/resources";
+export type { ProjectArtifactsResult };
+/**
+ * Node-only wrapper around `addProjectArtifactsToSolutionAsync`. Lives in its
+ * own file so the browser build can stub it out via `browser.json`
+ * `excludedImports` — the resource-builder-sdk it transitively imports is
+ * node-only and would otherwise break the cli browser bundle.
+ */
+export declare function ensureProjectArtifacts(args: {
+    solutionDir: string;
+    projectId: string;
+    projectName: string;
+    projectType: string;
+}): Promise<ProjectArtifactsResult>;

package/dist/tool.js

@@ -1,30 +1,36 @@
 import {
   metadata,
   registerCommands
-} from "./packager-tool-wm273rrd.js";
-import"./packager-tool-231njxzf.js";
-import"./packager-tool-25z1hdbm.js";
-import"./packager-tool-2q2qddqr.js";
+} from "./packager-tool-9x76z587.js";
+import"./packager-tool-neavt1k3.js";
+import"./packager-tool-1g6958de.js";
+import"./packager-tool-qfp49pq4.js";
 import"./packager-tool-7yjpwj92.js";
-import"./packager-tool-95ht91a8.js";
+import"./packager-tool-xa2xwzrq.js";
+import"./packager-tool-v2p6g3fd.js";
+import"./packager-tool-b0s5d4ek.js";
+import"./packager-tool-ny53xmsd.js";
 import"./packager-tool-9qecd4wb.js";
-import"./packager-tool-4f38v0ry.js";
-import"./packager-tool-1ps2qeqg.js";
-import"./packager-tool-q94g73f7.js";
-import"./packager-tool-kgkv7f24.js";
-import"./packager-tool-ek2dnj9h.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-1cb0d5e0.js";
+import"./packager-tool-5arsyj36.js";
+import"./packager-tool-6a7wdv5z.js";
+import"./packager-tool-1gt6js73.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-y3dezh8k.js";
 import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-qz3cg5tg.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-cqrsre00.js";
 import"./packager-tool-sc961w0q.js";
-import"./packager-tool-973f0r2g.js";
-import"./packager-tool-c23zrhj8.js";
-import"./packager-tool-9bnpe8n1.js";
-import"./packager-tool-ahm4ymrp.js";
+import"./packager-tool-ef2aypt3.js";
+import"./packager-tool-jpcm3xas.js";
 import"./packager-tool-c19w8vg9.js";
+import"./packager-tool-1yy9x4vk.js";
+import"./packager-tool-c23zrhj8.js";
 import"./packager-tool-wckvcay0.js";
 export {
   registerCommands,
   metadata
 };
 
-//# debugId=FEFDD8691754F44164756E2164756E21
+//# debugId=43B82928CD10412264756E2164756E21